protected RTMPMessage(RTMPMessage x)
{
Timestamp = x.Timestamp;
MessageType = x.MessageType;
StreamId = x.StreamId;
Body = x.Body;
}
public AggregateMessage(RTMPMessage x)
: base(x)
{
var messages = new List <RTMPMessage>();
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
var message_type = (RTMPMessageType)reader.ReadByte();
var length = reader.ReadUInt24();
var timestamp = reader.ReadUInt32();
var stream_id = reader.ReadUInt24();
var body = reader.ReadBytes(length);
var msg = new RTMPMessage(
message_type,
timestamp + x.Timestamp,
x.StreamId,
body);
var prevlen = reader.ReadUInt32();
if (prevlen == body.Length + 11)
{
messages.Add(msg);
}
}
}
}
public SetWindowSizeMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
WindowSize = reader.ReadUInt32();
}
}
protected RTMPMessage(RTMPMessage x)
{
Timestamp = x.Timestamp;
MessageType = x.MessageType;
StreamId = x.StreamId;
Body = x.Body;
}
public AbortMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
TargetChunkStream = (int)reader.ReadUInt32();
}
}
public AckMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
SequenceNumber = reader.ReadUInt32();
}
}
public SetChunkSizeMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
ChunkSize = (int)Math.Min(0x7FFFFFFL, reader.ReadUInt32());
}
}
public QueuedMessage(MessageDirection direction, int chunk_stream_id, RTMPMessage msg)
{
this.Direction = direction;
this.ChunkStreamId = chunk_stream_id;
this.Message = msg;
this.TimeStamp = Stopwatch.Elapsed;
}
public AbortMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
TargetChunkStream = (int)reader.ReadUInt32();
}
}
public SetChunkSizeMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
ChunkSize = (int)Math.Min(0x7FFFFFFL, reader.ReadUInt32());
}
}
public QueuedMessage(MessageDirection direction, int chunk_stream_id, RTMPMessage msg)
{
this.Direction = direction;
this.ChunkStreamId = chunk_stream_id;
this.Message = msg;
this.TimeStamp = Stopwatch.Elapsed;
}
public PingResponseMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
var type = (UserControlMessageType)reader.ReadUInt16();
LocalTimestamp = reader.ReadUInt32();
}
}
public StreamIsRecordedMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
var type = (UserControlMessageType)reader.ReadUInt16();
TargetStreamId = reader.ReadUInt32();
}
}
public UserControlMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
UserControlMessageType = (UserControlMessageType)reader.ReadUInt16();
UserControlMessagePayload = reader.ReadBytes(x.Body.Length - 2);
}
}
public SetPeerBandwidthMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
PeerBandwidth = reader.ReadUInt32();
LimitType = (PeerBandwidthLimitType)reader.ReadByte();
}
}
public void OnAudio(RTMPMessage msg)
{
if (IsAACHeader(msg)) {
audioHeader = msg;
OnHeaderChanged(msg);
}
OnContentChanged(msg);
}
public SetBufferLengthMessage(RTMPMessage x)
: base(x)
{
using (var reader = new RTMPBinaryReader(new MemoryStream(x.Body))) {
var type = (UserControlMessageType)reader.ReadUInt16();
TargetStreamId = reader.ReadUInt32();
BufferLength = TimeSpan.FromMilliseconds(reader.ReadUInt32());
}
}
public DataAMF0Message(RTMPMessage x)
: base(x)
{
using (var reader = new AMF0Reader(new MemoryStream(x.Body))) {
this.propertyName = (string)reader.ReadValue();
var arguments = new List <AMFValue>();
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
arguments.Add(reader.ReadValue());
}
this.arguments = arguments;
}
}
public void OnAudio(RTMPMessage msg)
{
if (timestampBase < 0 && msg.Timestamp > 0)
{
timestampBase = msg.Timestamp;
}
this.connection.PostMessage(3,
new RTMPMessage(
msg.MessageType,
msg.Timestamp - Math.Max(timestampBase, 0),
this.connection.StreamId,
msg.Body)
);
}
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;
}
}
}
private async Task SendMessage(int chunk_stream_id, RTMPMessage msg, CancellationToken cancel_token)
{
int offset = 0;
int fmt = 0;
while (msg.Body.Length - offset > 0)
{
switch (fmt)
{
case 0:
await SendAsync(writer => {
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;
}, cancel_token).ConfigureAwait(false);
fmt = 3;
break;
case 3:
await SendAsync(writer => {
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;
}, cancel_token).ConfigureAwait(false);
break;
}
}
}
public CommandAMF0Message(RTMPMessage x)
: base(x)
{
using (var reader = new AMF0Reader(new MemoryStream(x.Body))) {
this.commandName = (string)reader.ReadValue();
this.transactionId = (int)reader.ReadValue();
this.commandObject = reader.ReadValue();
if (AMFValue.IsNull(CommandObject))
{
this.commandObject = null;
}
var args = new List <AMFValue>();
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
args.Add(reader.ReadValue());
}
this.arguments = args;
}
}
public SetWindowSizeMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
WindowSize = reader.ReadUInt32();
}
}
public CommandAMF3Message(RTMPMessage x)
: base(x)
{
using (var reader=new AMF3Reader(new MemoryStream(x.Body))) {
this.commandName = (string)reader.ReadValue();
this.transactionId = (int)reader.ReadValue();
this.commandObject = reader.ReadValue();
if (AMFValue.IsNull(CommandObject)) {
this.commandObject = null;
}
var args = new List<AMFValue>();
while (reader.BaseStream.Position<reader.BaseStream.Length) {
args.Add(reader.ReadValue());
}
this.arguments = args;
}
}
protected void PostMessage(int chunk_stream_id, RTMPMessage msg)
{
postMessageQueue.Enqueue(new QueuedMessage(chunk_stream_id, msg));
}
public void OnAudio(RTMPMessage msg)
{
if (timestampBase<0 && msg.Timestamp>0) {
timestampBase = msg.Timestamp;
}
this.connection.PostMessage(3,
new RTMPMessage(
msg.MessageType,
msg.Timestamp - Math.Max(timestampBase, 0),
this.connection.StreamId,
msg.Body)
);
}
public StreamIsRecordedMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
var type = (UserControlMessageType)reader.ReadUInt16();
TargetStreamId = reader.ReadUInt32();
}
}
protected void PostMessage(int chunk_stream_id, RTMPMessage msg)
{
messageQueue.Enqueue(new QueuedMessage(QueuedMessage.MessageDirection.Out, chunk_stream_id, msg));
}
private bool IsAACHeader(RTMPMessage msg)
{
return
msg.MessageType==RTMPMessageType.Audio &&
msg.Body.Length>1 &&
(msg.Body[0]==0xAF &&
msg.Body[1]==0x00);
}
private void WriteMessage(Stream stream, RTMPMessage msg, long time_origin)
{
var timestamp = Math.Max(0, msg.Timestamp-time_origin);
using (var writer=new RTMPBinaryWriter(stream, true)) {
writer.Write((byte)msg.MessageType);
writer.WriteUInt24(msg.Body.Length);
writer.WriteUInt24((int)timestamp & 0xFFFFFF);
writer.Write((byte)((timestamp>>24) & 0xFF));
writer.WriteUInt24(0);
writer.Write(msg.Body, 0, msg.Body.Length);
writer.Write(msg.Body.Length+11);
}
}
public PingResponseMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
var type = (UserControlMessageType)reader.ReadUInt16();
LocalTimestamp = reader.ReadUInt32();
}
}
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;
}
private void OnContentChanged(RTMPMessage content)
{
if (streamIndex<0) OnHeaderChanged(content);
WriteMessage(bodyBuffer, content, timestampOrigin);
if (bodyBuffer.Length>=7500 ||
flushTimer.ElapsedMilliseconds>=100) {
FlushContents();
}
}
private bool IsAVCHeader(RTMPMessage msg)
{
return
msg.MessageType==RTMPMessageType.Video &&
msg.Body.Length>3 &&
(msg.Body[0]==0x17 &&
msg.Body[1]==0x00 &&
msg.Body[2]==0x00 &&
msg.Body[3]==0x00);
}
void OnAudio(RTMPMessage msg)
{
flvBuffer.OnAudio(msg);
}
private async Task ProcessMessage(RTMPMessage msg, CancellationToken cancel_token)
{
switch (msg.MessageType)
{
case RTMPMessageType.SetChunkSize:
await OnSetChunkSize(new SetChunkSizeMessage(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.Abort:
await OnAbort(new AbortMessage(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.Ack:
//Do nothing
break;
case RTMPMessageType.UserControl:
await OnUserControl(new UserControlMessage(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.SetWindowSize:
await OnSetWindowSize(new SetWindowSizeMessage(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.SetPeerBandwidth:
await OnSetPeerBandwidth(new SetPeerBandwidthMessage(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.Audio:
await OnAudio(msg, cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.Video:
await OnVideo(msg, cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.DataAMF3:
await OnData(new DataAMF3Message(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.DataAMF0:
await OnData(new DataAMF0Message(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.CommandAMF3:
await OnCommand(new CommandAMF3Message(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.CommandAMF0:
await OnCommand(new CommandAMF0Message(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.Aggregate:
await OnAggregate(new AggregateMessage(msg), cancel_token).ConfigureAwait(false);
break;
case RTMPMessageType.SharedObjectAMF3:
case RTMPMessageType.SharedObjectAMF0:
//TODO:Not implemented
break;
default:
//TODO:Unknown message
break;
}
}
protected virtual Task OnVideo(RTMPMessage msg, CancellationToken cancel_token)
{
return(Task.Delay(0));
}
protected virtual async Task OnVideo(RTMPMessage msg, CancellationToken cancel_token)
{
}
private async Task SendMessage(int chunk_stream_id, RTMPMessage msg, CancellationToken cancel_token)
{
int offset = 0;
int fmt = 0;
while (msg.Body.Length-offset>0) {
switch (fmt) {
case 0:
await SendAsync(writer => {
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;
}, cancel_token);
fmt = 3;
break;
case 3:
await SendAsync(writer => {
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;
}, cancel_token);
break;
}
}
}
private async Task ProcessMessage(RTMPMessage msg, CancellationToken cancel_token)
{
switch (msg.MessageType) {
case RTMPMessageType.SetChunkSize:
await OnSetChunkSize(new SetChunkSizeMessage(msg), cancel_token);
break;
case RTMPMessageType.Abort:
await OnAbort(new AbortMessage(msg), cancel_token);
break;
case RTMPMessageType.Ack:
//Do nothing
break;
case RTMPMessageType.UserControl:
await OnUserControl(new UserControlMessage(msg), cancel_token);
break;
case RTMPMessageType.SetWindowSize:
await OnSetWindowSize(new SetWindowSizeMessage(msg), cancel_token);
break;
case RTMPMessageType.SetPeerBandwidth:
await OnSetPeerBandwidth(new SetPeerBandwidthMessage(msg), cancel_token);
break;
case RTMPMessageType.Audio:
await OnAudio(msg, cancel_token);
break;
case RTMPMessageType.Video:
await OnVideo(msg, cancel_token);
break;
case RTMPMessageType.DataAMF3:
await OnData(new DataAMF3Message(msg), cancel_token);
break;
case RTMPMessageType.DataAMF0:
await OnData(new DataAMF0Message(msg), cancel_token);
break;
case RTMPMessageType.CommandAMF3:
await OnCommand(new CommandAMF3Message(msg), cancel_token);
break;
case RTMPMessageType.CommandAMF0:
await OnCommand(new CommandAMF0Message(msg), cancel_token);
break;
case RTMPMessageType.Aggregate:
await OnAggregate(new AggregateMessage(msg), cancel_token);
break;
case RTMPMessageType.SharedObjectAMF3:
case RTMPMessageType.SharedObjectAMF0:
//TODO:Not implemented
break;
default:
//TODO:Unknown message
break;
}
}
private Task OnVideo(RTMPMessage msg, CancellationToken cancel_token)
{
flvBuffer.OnVideo(msg);
return(Task.Delay(0));
}
private Task OnVideo(RTMPMessage msg, CancellationToken cancel_token)
{
flvBuffer.OnVideo(msg);
return Task.Delay(0);
}
public AckMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
SequenceNumber = reader.ReadUInt32();
}
}
public DataAMF3Message(RTMPMessage x)
: base(x)
{
using (var reader=new AMF3Reader(new MemoryStream(x.Body))) {
this.propertyName = (string)reader.ReadValue();
var arguments = new List<AMFValue>();
while (reader.BaseStream.Position<reader.BaseStream.Length) {
arguments.Add(reader.ReadValue());
}
this.arguments = arguments;
}
}
public AggregateMessage(RTMPMessage x)
: base(x)
{
var messages = new List<RTMPMessage>();
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
while (reader.BaseStream.Position<reader.BaseStream.Length) {
var message_type = (RTMPMessageType)reader.ReadByte();
var length = reader.ReadUInt24();
var timestamp = reader.ReadUInt32();
var stream_id = reader.ReadUInt24();
var body = reader.ReadBytes(length);
var msg = new RTMPMessage(
message_type,
timestamp + x.Timestamp,
x.StreamId,
body);
var prevlen = reader.ReadUInt32();
if (prevlen==body.Length+11) {
messages.Add(msg);
}
}
}
}
protected DataMessage(RTMPMessage x)
: base(x)
{
}
protected CommandMessage(RTMPMessage x)
: base(x)
{
}
protected DataMessage(RTMPMessage x)
: base(x)
{
}
private void ProcessMessage(RTMPMessage msg)
{
switch (msg.MessageType)
{
case RTMPMessageType.SetChunkSize:
OnSetChunkSize(new SetChunkSizeMessage(msg));
break;
case RTMPMessageType.Abort:
OnAbort(new AbortMessage(msg));
break;
case RTMPMessageType.Ack:
//Do nothing
break;
case RTMPMessageType.UserControl:
OnUserControl(new UserControlMessage(msg));
break;
case RTMPMessageType.SetWindowSize:
OnSetWindowSize(new SetWindowSizeMessage(msg));
break;
case RTMPMessageType.SetPeerBandwidth:
OnSetPeerBandwidth(new SetPeerBandwidthMessage(msg));
break;
case RTMPMessageType.Audio:
OnAudio(msg);
break;
case RTMPMessageType.Video:
OnVideo(msg);
break;
case RTMPMessageType.DataAMF3:
OnData(new DataAMF3Message(msg));
break;
case RTMPMessageType.DataAMF0:
OnData(new DataAMF0Message(msg));
break;
case RTMPMessageType.CommandAMF3:
OnCommand(new CommandAMF3Message(msg));
break;
case RTMPMessageType.CommandAMF0:
OnCommand(new CommandAMF0Message(msg));
break;
case RTMPMessageType.Aggregate:
OnAggregate(new AggregateMessage(msg));
break;
case RTMPMessageType.SharedObjectAMF3:
case RTMPMessageType.SharedObjectAMF0:
//TODO:Not implemented
break;
default:
//TODO:Unknown message
break;
}
}
void OnVideo(RTMPMessage msg)
{
flvBuffer.OnVideo(msg);
}
public SetPeerBandwidthMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
PeerBandwidth = reader.ReadUInt32();
LimitType = (PeerBandwidthLimitType)reader.ReadByte();
}
}
public void OnAudio(RTMPMessage msg)
{
this.connection.PostMessage(3,
new RTMPMessage(
msg.MessageType,
msg.Timestamp,
this.connection.StreamId,
msg.Body)
);
}
public UserControlMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
UserControlMessageType = (UserControlMessageType)reader.ReadUInt16();
UserControlMessagePayload = reader.ReadBytes(x.Body.Length-2);
}
}
protected CommandMessage(RTMPMessage x)
: base(x)
{
}
public SetBufferLengthMessage(RTMPMessage x)
: base(x)
{
using (var reader=new RTMPBinaryReader(new MemoryStream(x.Body))) {
var type = (UserControlMessageType)reader.ReadUInt16();
TargetStreamId = reader.ReadUInt32();
BufferLength = TimeSpan.FromMilliseconds(reader.ReadUInt32());
}
}
public void OnVideo(RTMPMessage msg)
{
if (IsAVCHeader(msg)) {
videoHeader = msg;
OnHeaderChanged(msg);
}
OnContentChanged(msg);
}
