WriteUInt32() public method

public WriteUInt32 ( long value ) : void
value long
return void
Beispiel #1
0
            private static byte[] CreateBody(long target_stream_id, TimeSpan buffer_length)
            {
                var s = new MemoryStream();

                using (var writer = new RTMPBinaryWriter(s)) {
                    writer.WriteUInt16((int)UserControlMessageType.SetBufferLength);
                    writer.WriteUInt32(target_stream_id);
                    writer.WriteUInt32((long)buffer_length.TotalMilliseconds);
                }
                return(s.ToArray());
            }
Beispiel #2
0
 private static byte[] CreateBody(int chunk_size)
 {
   var s = new MemoryStream();
   using (var writer=new RTMPBinaryWriter(s)) {
     writer.WriteUInt32(Math.Max(1, Math.Min(chunk_size, 0x7FFFFFFF)));
   }
   return s.ToArray();
 }
 private static byte[] CreateBody(int target_chunk_stream)
 {
     var s = new MemoryStream();
       using (var writer=new RTMPBinaryWriter(s)) {
     writer.WriteUInt32(target_chunk_stream);
       }
       return s.ToArray();
 }
Beispiel #4
0
        private static byte[] CreateBody(long window_size)
        {
            var s = new MemoryStream();

            using (var writer = new RTMPBinaryWriter(s)) {
                writer.WriteUInt32(window_size);
            }
            return(s.ToArray());
        }
Beispiel #5
0
        private static byte[] CreateBody(long sequence_number)
        {
            var s = new MemoryStream();

            using (var writer = new RTMPBinaryWriter(s)) {
                writer.WriteUInt32(sequence_number & 0xFFFFFFFF);
            }
            return(s.ToArray());
        }
Beispiel #6
0
        private static byte[] CreateBody(int target_chunk_stream)
        {
            var s = new MemoryStream();

            using (var writer = new RTMPBinaryWriter(s)) {
                writer.WriteUInt32(target_chunk_stream);
            }
            return(s.ToArray());
        }
Beispiel #7
0
        private static byte[] CreateBody(int chunk_size)
        {
            var s = new MemoryStream();

            using (var writer = new RTMPBinaryWriter(s)) {
                writer.WriteUInt32(Math.Max(1, Math.Min(chunk_size, 0x7FFFFFFF)));
            }
            return(s.ToArray());
        }
Beispiel #8
0
            private static byte[] CreateBody(long local_timestamp)
            {
                var s = new MemoryStream();

                using (var writer = new RTMPBinaryWriter(s)) {
                    writer.WriteUInt16((int)UserControlMessageType.PingResponse);
                    writer.WriteUInt32(local_timestamp);
                }
                return(s.ToArray());
            }
Beispiel #9
0
        private static byte[] CreateBody(long bandwidth, PeerBandwidthLimitType limit_type)
        {
            var s = new MemoryStream();

            using (var writer = new RTMPBinaryWriter(s)) {
                writer.WriteUInt32(bandwidth);
                writer.Write((byte)limit_type);
            }
            return(s.ToArray());
        }
Beispiel #10
0
            private static byte[] CreateBody(long target_stream_id)
            {
                var s = new MemoryStream();

                using (var writer = new RTMPBinaryWriter(s)) {
                    writer.WriteUInt16((int)UserControlMessageType.StreamIsRecorded);
                    writer.WriteUInt32(target_stream_id);
                }
                return(s.ToArray());
            }
        void SendMessage(int chunk_stream_id, RTMPMessage msg)
        {
            int offset = 0;
            int fmt    = 0;

            while (msg.Body.Length - offset > 0)
            {
                switch (fmt)
                {
                case 0:
                    Send(s => {
                        using (var writer = new RTMPBinaryWriter(s)) {
                            writer.Write((byte)((fmt << 6) | chunk_stream_id));
                            if (msg.Timestamp > 0xFFFFFF)
                            {
                                writer.WriteUInt24(0xFFFFFF);
                            }
                            else
                            {
                                writer.WriteUInt24((int)msg.Timestamp);
                            }
                            writer.WriteUInt24(msg.Body.Length);
                            writer.Write((byte)msg.MessageType);
                            writer.WriteUInt32LE(msg.StreamId);
                            if (msg.Timestamp > 0xFFFFFF)
                            {
                                writer.WriteUInt32(msg.Timestamp);
                            }
                            int chunk_len = Math.Min(sendChunkSize, msg.Body.Length - offset);
                            writer.Write(msg.Body, offset, chunk_len);
                            offset += chunk_len;
                        }
                    });
                    fmt = 3;
                    break;

                case 3:
                    Send(s => {
                        using (var writer = new RTMPBinaryWriter(s)) {
                            writer.Write((byte)((fmt << 6) | chunk_stream_id));
                            int chunk_len = Math.Min(sendChunkSize, msg.Body.Length - offset);
                            writer.Write(msg.Body, offset, chunk_len);
                            offset += chunk_len;
                        }
                    });
                    break;
                }
            }
        }
Beispiel #12
0
 private static byte[] CreateBody(long bandwidth, PeerBandwidthLimitType limit_type)
 {
     var s = new MemoryStream();
       using (var writer=new RTMPBinaryWriter(s)) {
     writer.WriteUInt32(bandwidth);
     writer.Write((byte)limit_type);
       }
       return s.ToArray();
 }
Beispiel #13
0
 private static byte[] CreateBody(long sequence_number)
 {
     var s = new MemoryStream();
       using (var writer=new RTMPBinaryWriter(s)) {
     writer.WriteUInt32(sequence_number & 0xFFFFFFFF);
       }
       return s.ToArray();
 }
Beispiel #14
0
 private static byte[] CreateBody(long target_stream_id)
 {
     var s = new MemoryStream();
     using (var writer=new RTMPBinaryWriter(s)) {
       writer.WriteUInt16((int)UserControlMessageType.StreamIsRecorded);
       writer.WriteUInt32(target_stream_id);
     }
     return s.ToArray();
 }
Beispiel #15
0
 private static byte[] CreateBody(long target_stream_id, TimeSpan buffer_length)
 {
     var s = new MemoryStream();
     using (var writer=new RTMPBinaryWriter(s)) {
       writer.WriteUInt16((int)UserControlMessageType.SetBufferLength);
       writer.WriteUInt32(target_stream_id);
       writer.WriteUInt32((long)buffer_length.TotalMilliseconds);
     }
     return s.ToArray();
 }
 private void OnHeaderChanged(RTMPMessage msg)
 {
     FlushContents();
       var s = new MemoryStream();
       using (s) {
     using (var writer=new RTMPBinaryWriter(s, true)) {
       writer.Write((byte)'F');
       writer.Write((byte)'L');
       writer.Write((byte)'V');
       writer.Write((byte)1);
       writer.Write((byte)5);
       writer.WriteUInt32(9);
       writer.WriteUInt32(0);
     }
     if (metadata!=null)    WriteMessage(s, metadata,    0xFFFFFFFF);
     if (audioHeader!=null) WriteMessage(s, audioHeader, 0xFFFFFFFF);
     if (videoHeader!=null) WriteMessage(s, videoHeader, 0xFFFFFFFF);
       }
       streamIndex     = TargetChannel.GenerateStreamID();
       streamOrigin    = DateTime.Now;
       timestampOrigin = msg.Timestamp;
       var bytes = s.ToArray();
       contents.ContentHeader = new Content(streamIndex, TimeSpan.Zero, position, bytes);
       position += bytes.Length;
 }
Beispiel #17
0
 private static byte[] CreateBody(long window_size)
 {
     var s = new MemoryStream();
       using (var writer=new RTMPBinaryWriter(s)) {
     writer.WriteUInt32(window_size);
       }
       return s.ToArray();
 }
Beispiel #18
0
 private static byte[] CreateBody(long local_timestamp)
 {
     var s = new MemoryStream();
     using (var writer=new RTMPBinaryWriter(s)) {
       writer.WriteUInt16((int)UserControlMessageType.PingResponse);
       writer.WriteUInt32(local_timestamp);
     }
     return s.ToArray();
 }
 void SendMessage(int chunk_stream_id, RTMPMessage msg)
 {
     int offset = 0;
       int fmt = 0;
       while (msg.Body.Length-offset>0) {
     switch (fmt) {
     case 0:
       Send(s => {
     using (var writer=new RTMPBinaryWriter(s)) {
       writer.Write((byte)((fmt<<6) | chunk_stream_id));
       if (msg.Timestamp>0xFFFFFF) {
         writer.WriteUInt24(0xFFFFFF);
       }
       else {
         writer.WriteUInt24((int)msg.Timestamp);
       }
       writer.WriteUInt24(msg.Body.Length);
       writer.Write((byte)msg.MessageType);
       writer.WriteUInt32LE(msg.StreamId);
       if (msg.Timestamp>0xFFFFFF) {
         writer.WriteUInt32(msg.Timestamp);
       }
       int chunk_len = Math.Min(sendChunkSize, msg.Body.Length-offset);
       writer.Write(msg.Body, offset, chunk_len);
       offset += chunk_len;
     }
       });
       fmt = 3;
       break;
     case 3:
       Send(s => {
     using (var writer=new RTMPBinaryWriter(s)) {
       writer.Write((byte)((fmt<<6) | chunk_stream_id));
       int chunk_len = Math.Min(sendChunkSize, msg.Body.Length-offset);
       writer.Write(msg.Body, offset, chunk_len);
       offset += chunk_len;
     }
       });
       break;
     }
       }
 }