public override void Encode(Stream outputStream, bool withHeader = true)
        {
            if (outputStream == null || !outputStream.CanWrite)
            {
                return;
            }
            if (withHeader)
            {
                NetworkMessageHeader.Encode(outputStream);
            }
            PayloadHeader.Encode(outputStream);
            BaseType.WriteToStream(outputStream, BitConverter.GetBytes(MessageSequenceNumber));
            BaseType.WriteToStream(outputStream, BitConverter.GetBytes(ChunkOffset));
            BaseType.WriteToStream(outputStream, BitConverter.GetBytes(TotalSize));
            int length = -1;

            if (ChunkData != null)
            {
                length = ChunkData.Length;
            }
            BaseType.WriteToStream(outputStream, BitConverter.GetBytes(length));
            for (int i = 0; i < length; i++)
            {
                // ReSharper disable once PossibleNullReferenceException
                outputStream.WriteByte(ChunkData[i]);
            }
        }
        public override void Encode(Stream outputStream, bool withHeader = true)
        {
            if (outputStream == null || !outputStream.CanWrite)
            {
                return;
            }

            if (withHeader)
            {
                // 1. Network Message Header
                NetworkMessageHeader.Encode(outputStream);
            }

            // 2. DataSet Payload Header
            PayloadHeader.Encode(outputStream);
            EncodeChunk(outputStream);
        }
        private static async Task <(List <PayloadHeader> chunkHeaders, List <PayloadHeader> keyframeHeaders)> UnpackDataHeaders(FileStream fs, Header header)
        {
            fs.Seek(header.headerLength + 4, SeekOrigin.Begin);
            var chunkHeaders    = new List <PayloadHeader>();
            var keyframeHeaders = new List <PayloadHeader>();
            var buffer          = new byte[10];

            for (var k = 0; k < header.chunkCount; k++)
            {
                await fs.ReadAsync(buffer);

                chunkHeaders.Add(PayloadHeader.FromBytes(buffer));
            }

            for (var k = 0; k < header.keyframeCount; k++)
            {
                await fs.ReadAsync(buffer);

                keyframeHeaders.Add(PayloadHeader.FromBytes(buffer));
            }
            return(chunkHeaders, keyframeHeaders);
        }
        private void OnGetResponse(IAsyncResult asyncResult)
        {
            // get the response
            HttpWebRequest req = (HttpWebRequest)asyncResult.AsyncState;

            try
            {
                HttpWebResponse resp = (HttpWebResponse)req.EndGetResponse(asyncResult);
                Stream          s    = resp.GetResponseStream();


                while (true)
                {
                    CommonHeader heder = new CommonHeader();
                    //ByteArrayToStructure(s, ref heder);
                    var buff = ReadBytes(s, 8);
                    heder.StartByte  = buff[0];
                    heder.Type       = buff[1];
                    heder.SequenceNo = BitConverter.ToInt16(buff, 2);;
                    heder.TimeStamp  = BitConverter.ToInt32(buff, 4);;
                    PayloadHeader playload = new PayloadHeader();
                    //ByteArrayToStructure(s, ref playload);
                    buff = ReadBytes(s, 128);

                    playload.StartCode   = BitConverter.ToInt32(buff, 0);
                    playload.JpgDataSize = BitConverter.ToUInt16(new byte[] { buff[6], buff[5], buff[4], 0 }, 0);
                    playload.PadingSize  = buff[7];

                    if (((CommonHeader)heder).Type == 0x02)
                    {
                        if (playload.JpgDataSize > 0)
                        {
                            var data = ReadBytes(s, playload.JpgDataSize);
                            _liveViewData.FocusX            = BitConverter.ToInt16(new byte[] { data[1], data[0] }, 0);
                            _liveViewData.FocusY            = BitConverter.ToInt16(new byte[] { data[3], data[2] }, 0);;
                            _liveViewData.FocusFrameXSize   = BitConverter.ToInt16(new byte[] { data[5], data[4] }, 0) - _liveViewData.FocusX;
                            _liveViewData.FocusFrameYSize   = BitConverter.ToInt16(new byte[] { data[7], data[6] }, 0) - _liveViewData.FocusY;
                            _liveViewData.HaveFocusData     = true;
                            _liveViewData.Focused           = data[9] != 0;
                            _liveViewData.ImageWidth        = 10000;
                            _liveViewData.ImageHeight       = 10000;
                            _liveViewData.IsLiveViewRunning = true;
                            Console.WriteLine(playload.JpgDataSize);
                        }
                    }
                    else
                    {
                        _liveViewData.ImageData = ReadBytes(s, playload.JpgDataSize);
                    }

                    if (playload.PadingSize > 0)
                    {
                        ReadBytes(s, playload.PadingSize);
                    }
                    if (_shoulStopLiveView)
                    {
                        break;
                    }
                }
                resp.Close();
            }
            catch (Exception ex)
            {
                Log.Error("Unable to download stream ", ex);
            }
        }