public void WriteData(AmfWriter writer, object obj)
{
if (!(obj is IExternalizable))
{
IDictionary <string, object> dictionary1;
if ((dictionary1 = obj as IDictionary <string, object>) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Array);
writer.WriteAmf3AssociativeArray(dictionary1);
return;
}
IDictionary dictionary2;
if ((dictionary2 = obj as IDictionary) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Dictionary);
writer.WriteAmf3Dictionary(dictionary2);
}
IEnumerable source;
if ((source = obj as IEnumerable) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Array);
writer.WriteAmf3Array((Array)source.Cast <object>().ToArray <object>());
return;
}
}
writer.WriteMarker(Amf3TypeMarkers.Object);
writer.WriteAmf3Object(obj);
}
public byte[] Encode()
{
using (var ms = new MemoryStream())
{
var aw = new AmfWriter(ms);
aw.Write(CommandName);
int transid = 0;
switch (transid)
{
case -2:
transid = CurrentTransactionID++;
break;
case -1:
transid = 0;
break;
default:
transid = TransactionID;
break;
}
aw.Write(transid);
aw.Write(CommandObject);
if (Arguments != null)
{
Arguments.ForEach(aw.Write);
}
return(ms.ToArray());
}
}
public static void WriteTo(AmfWriter writer, byte format, int chunkStreamId)
{
if (chunkStreamId <= 63)
{
// 0 1 2 3 4 5 6 7
// +-+-+-+-+-+-+-+-+
// |fmt| cs id |
// +-+-+-+-+-+-+-+-+
writer.WriteByte((byte)((format << 6) + chunkStreamId));
}
else if (chunkStreamId <= 320)
{
// 0 1
// 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |fmt| 0 | cs id - 64 |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
writer.WriteByte((byte)(format << 6));
writer.WriteByte((byte)(chunkStreamId - 64));
}
else
{
// 0 1 3
// 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |fmt| 1 | cs id - 64 |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
writer.WriteByte((byte)((format << 6) | 1));
writer.WriteByte((byte)((chunkStreamId - 64) & 0xff));
writer.WriteByte((byte)((chunkStreamId - 64) >> 8));
}
}
public void WriteData(AmfWriter writer, object obj)
{
var externalizable = obj is IExternalizable;
// if IExternalizable then use those methods, even if it is a collection
if (!externalizable)
{
IDictionary <string, object> stringDictionary;
IDictionary dictionary;
IEnumerable enumerable;
if ((stringDictionary = obj as IDictionary <string, object>) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Array);
writer.WriteAmf3AssociativeArray(stringDictionary);
return;
}
if ((dictionary = obj as IDictionary) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Dictionary);
writer.WriteAmf3Dictionary(dictionary);
}
if ((enumerable = obj as IEnumerable) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Array);
writer.WriteAmf3Array(enumerable.Cast <object>().ToArray());
return;
}
}
writer.WriteMarker(Amf3TypeMarkers.Object);
writer.WriteAmf3Object(obj);
}
public void WriteData(AmfWriter writer, object obj)
{
var externalizable = obj is IExternalizable;
// if IExternalizable then use those methods, even if it is a collection
if (!externalizable)
{
IDictionary<string, object> stringDictionary;
IDictionary dictionary;
IEnumerable enumerable;
if ((stringDictionary = obj as IDictionary<string, object>) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Array);
writer.WriteAmf3AssociativeArray(stringDictionary);
return;
}
if ((dictionary = obj as IDictionary) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Dictionary);
writer.WriteAmf3Dictionary(dictionary);
}
if ((enumerable = obj as IEnumerable) != null)
{
writer.WriteMarker(Amf3TypeMarkers.Array);
writer.WriteAmf3Array(enumerable.Cast<object>().ToArray());
return;
}
}
writer.WriteMarker(Amf3TypeMarkers.Object);
writer.WriteAmf3Object(obj);
}
public static void WriteTo(AmfWriter writer, Snapshot previous, Snapshot next, int chunkLength, Space <byte> message)
{
Kon.Assert(
!previous.Ready || previous.ChunkStreamId == next.ChunkStreamId,
"previous and next describe two different chunk streams");
Kon.Assert(
next.MessageLength == message.Length,
"mismatch between reported message length and actual message length");
// we don't write zero-length packets, and as state for `next` and `previous` won't match what our peer
// sees if we pass a zero-length message here. zero-length sends should be filtered out at a higher level.
Kon.Assert(
next.MessageLength != 0,
"message length cannot be zero");
var header = GetInitialHeaderType();
for (var i = 0; i < next.MessageLength; i += chunkLength)
{
if (i == 0)
{
BasicHeader.WriteTo(writer, (byte)header, next.ChunkStreamId);
MessageHeader.WriteTo(writer, header, next);
}
else
{
BasicHeader.WriteTo(writer, (byte)MessageHeader.Type.Type3, next.ChunkStreamId);
}
var count = Math.Min(chunkLength, next.MessageLength - i);
var slice = message.Slice(i, count);
writer.WriteBytes(slice);
}
MessageHeader.Type GetInitialHeaderType()
{
if (!previous.Ready || next.MessageStreamId != previous.MessageStreamId)
{
return(MessageHeader.Type.Type0);
}
if (next.MessageLength != previous.MessageLength || next.ContentType != previous.ContentType)
{
return(MessageHeader.Type.Type1);
}
if (next.Timestamp != previous.Timestamp)
{
return(MessageHeader.Type.Type2);
}
return(MessageHeader.Type.Type3);
}
}
byte[] GetMessageBytes(RtmpEvent message, Action <AmfWriter, RtmpEvent> handler)
{
using (var stream = new MemoryStream())
using (var messageWriter = new AmfWriter(stream, writer.SerializationContext, objectEncoding))
{
handler(messageWriter, message);
return(stream.ToArray());
}
}
public void ApplyValues()
{
var writer = new AmfWriter();
writer.WriteString("createStream");
writer.WriteNumber(TransactionId);
writer.WriteNull();
Data = writer.GetByteArray();
}
public FlvPacketWriter(AmfWriter writer, ObjectEncoding objectEncoding)
{
this.objectEncoding = objectEncoding;
this.writer = writer;
queuedPackets = new ConcurrentQueue <RtmpPacket>();
packetAvailableEvent = new AutoResetEvent(false);
Continue = true;
}
public RtmpPacketWriter(AmfWriter writer, ObjectEncoding objectEncoding)
{
this._objectEncoding = objectEncoding;
this._writer = writer;
this._rtmpHeaders = new Dictionary <int, RtmpHeader>();
this._rtmpPackets = new Dictionary <int, RtmpPacket>();
this._queuedPackets = new ConcurrentQueue <RtmpPacket>();
this._packetAvailableEvent = new AutoResetEvent(false);
this.Continue = true;
}
public RtmpPacketWriter(AmfWriter writer, ObjectEncoding objectEncoding)
{
this.objectEncoding = objectEncoding;
this.writer = writer;
rtmpHeaders = new Dictionary<int, RtmpHeader>();
queuedPackets = new ConcurrentQueue<RtmpPacket>();
packetAvailableEvent = new AutoResetEvent(false);
Continue = true;
}
private byte[] GetMessageBytes(RtmpEvent message, Action <AmfWriter, RtmpEvent> handler)
{
using (MemoryStream memoryStream = new MemoryStream())
{
using (AmfWriter amfWriter = new AmfWriter((Stream)memoryStream, this._writer.SerializationContext, this._objectEncoding))
{
handler(amfWriter, message);
return(memoryStream.ToArray());
}
}
}
void WriteData(AmfWriter writer, RtmpEvent o, ObjectEncoding encoding)
{
if (o is Command)
{
WriteCommandOrData(writer, o, encoding);
}
else if (o is ByteData)
{
writer.WriteBytes(((ByteData)o).Data);
}
}
public byte[] Encode()
{
using (var ms = new MemoryStream())
{
var aw = new AmfWriter(ms);
aw.Write(Name);
Data.ForEach(aw.Write);
return ms.ToArray();
}
}
public byte[] Encode()
{
using (var ms = new MemoryStream())
{
var aw = new AmfWriter(ms);
aw.Write(Name);
Data.ForEach(aw.Write);
return(ms.ToArray());
}
}
public FlvPacketWriter(AmfWriter writer, ObjectEncoding objectEncoding)
{
this._objectEncoding = objectEncoding;
this._writer = writer;
_packetQueue = new ConcurrentQueue <RtmpPacket>();
_packetAvailableEvent = new AutoResetEvent(false);
_started = true;
}
private void WriteData(AmfWriter writer, RtmpEvent o, ObjectEncoding encoding)
{
Command command = o as Command;
if (command.MethodCall == null)
{
this.WriteCommandOrData(writer, o, encoding);
}
else
{
writer.WriteBytes(command.Buffer);
}
}
void WriteData(AmfWriter writer, RtmpMessage o, ObjectEncoding encoding)
{
var command = o as Command;
if (command.MethodCall == null)
{
WriteCommandOrData(writer, o, encoding);
}
else
{
writer.WriteBytes(command.Buffer);
}
}
static async Task WriteC2Async(Stream stream, uint remoteTime, Space <byte> remoteRandom)
{
var time = Ts.CurrentTime;
var writer = new AmfWriter(new byte[FrameLength], EmptyContext);
writer.WriteUInt32(remoteTime); // "time": a copy of s1 time
writer.WriteUInt32(time); // "time2": current local time
writer.WriteBytes(remoteRandom); // "random echo": a copy of s1 random
await stream.WriteAsync(writer.Span);
writer.Return();
}
async Task WriteOnceAsync()
{
await reset.WaitAsync();
while (!token.IsCancellationRequested && queue.TryDequeue(out var packet))
{
// quickly estimate the maximum required length for this message. our estimation is as follows:
//
// - [payload]
// - take the message length, and add the chunk + message headers.
//
// - [chunk headers]
// - all chunk headers begin with a 0-3 byte header, indicating chunk stream id + message header
// format.
// - the one byte variant can encode chunk stream ids up to and including #63. we don't expect to
// encode that many streams right now (unless a user library wants it), so we can assume 1 byte
// chunk headers for now.
//~
// - [message headers]
// - the first message header must be a type 0 (new) header, which is 11 bytes large.
// - all further message headers can be a type 3 (continuation) header, which is 0 bytes large.
//
// - [total]
// - message_length + chunk_count * 1 + 11
//
var packetLength = packet.Span.Length;
var chunkCount = packetLength / chunkLength + 1;
var estimatedMaxLength = packetLength + chunkCount + 11;
var writer = new AmfWriter(estimatedMaxLength, context);
var previous = streams.TryGetValue(packet.StreamId, out var value) ? value : default(ChunkStream.Snapshot);
var next = previous.Clone();
next.Ready = true;
next.ContentType = packet.Type;
next.ChunkStreamId = packet.StreamId;
next.MessageStreamId = 0;
next.MessageLength = packetLength;
next.Timestamp = Ts.CurrentTime;
streams[packet.StreamId] = next;
ChunkStream.WriteTo(writer, previous, next, chunkLength, packet.Span);
await stream.WriteAsync(writer.Span, token);
writer.Return();
}
}
public static Task WriteAsync(Stream stream, RtmpHandshake h, bool writeVersion)
{
using (var memoryStream = new MemoryStream())
using (var writer = new AmfWriter(memoryStream, null))
{
if (writeVersion)
writer.WriteByte(h.Version);
writer.WriteUInt32(h.Time);
writer.WriteUInt32(h.Time2);
writer.WriteBytes(h.Random);
var buffer = memoryStream.ToArray();
return stream.WriteAsync(buffer, 0, buffer.Length);
}
}
private void WriteCommandOrData(AmfWriter writer, RtmpEvent o, ObjectEncoding encoding)
{
var command = o as Command;
var methodCall = command.MethodCall;
var isInvoke = command is Invoke;
// write the method name or result type (first section)
var isRequest = methodCall.CallStatus == CallStatus.Request;
var isResult = methodCall.CallStatus == CallStatus.Result;
if (isRequest)
{
writer.WriteAmfItem(ObjectEncoding.Amf0, methodCall.Name);
}
else
{
writer.WriteAmfItem(ObjectEncoding.Amf0, methodCall.IsSuccess ? "_result" : "_error");
}
if (isInvoke)
{
writer.WriteAmfItem(ObjectEncoding.Amf0, command.InvokeId);
writer.WriteAmfItem(encoding, command.ConnectionParameters);
}
if (isRequest || isResult)
{
// write arguments
foreach (var arg in methodCall.Parameters)
{
writer.WriteAmfItem(encoding, arg);
}
}
else if (isInvoke)
{
// write the result
if (!methodCall.IsSuccess)
{
methodCall.Parameters = new object[]
{ new StatusAsObject(StatusCode.CallFailed, "error", "Call failed.") }
}
;
writer.WriteAmfItem(encoding, methodCall.Parameters);
}
}
}
private void WriteCommandOrData(AmfWriter writer, RtmpEvent o, ObjectEncoding encoding)
{
Command command = o as Command;
Method methodCall = command.MethodCall;
bool flag1 = command is Invoke;
bool flag2 = methodCall.CallStatus == CallStatus.Request;
bool flag3 = methodCall.CallStatus == CallStatus.Result;
if (flag2)
{
writer.WriteAmfItem(ObjectEncoding.Amf0, (object)methodCall.Name);
}
else
{
writer.WriteAmfItem(ObjectEncoding.Amf0, methodCall.IsSuccess ? (object)"_result" : (object)"_error");
}
if (flag1)
{
writer.WriteAmfItem(ObjectEncoding.Amf0, (object)command.InvokeId);
writer.WriteAmfItem(encoding, command.ConnectionParameters);
}
if (flag2 | flag3)
{
foreach (object parameter in methodCall.Parameters)
{
writer.WriteAmfItem(encoding, parameter);
}
}
else
{
if (!flag1)
{
return;
}
if (!methodCall.IsSuccess)
{
methodCall.Parameters = new object[1]
{
(object)new StatusAsObject("NetConnection.Call.Failed", "error", "Call failed.")
}
}
;
writer.WriteAmfItem(encoding, (object)methodCall.Parameters);
}
}
}
static async Task <(uint time, Space <byte> random)> WriteC1Async(Stream stream)
{
var writer = new AmfWriter(new byte[C1Length], EmptyContext);
var random = RandomEx.GetBytes(RandomLength);
var time = Ts.CurrentTime;
writer.WriteByte(3); // rtmp version (constant 3) [c0]
writer.WriteUInt32(time); // time [c1]
writer.WriteUInt32(0); // zero [c1]
writer.WriteBytes(random); // random bytes [c1]
await stream.WriteAsync(writer.Span);
writer.Return();
return(time, random);
}
public static Task WriteAsync(Stream stream, RtmpHandshake h, bool writeVersion)
{
using (var memoryStream = new MemoryStream())
using (var writer = new AmfWriter(memoryStream, null))
{
if (writeVersion)
{
writer.WriteByte(h.Version);
}
writer.WriteUInt32(h.Time);
writer.WriteUInt32(h.Time2);
writer.WriteBytes(h.Random);
var buffer = memoryStream.ToArray();
return(stream.WriteAsync(buffer, 0, buffer.Length));
}
}
void WriteCommandOrData(AmfWriter writer, RtmpEvent o, ObjectEncoding encoding)
{
var command = o as Command;
var methodCall = command.MethodCall;
var isInvoke = command is Invoke;
// write the method name or result type (first section)
if (methodCall.Name == "@setDataFrame")
{
writer.WriteAmfItem(encoding, command.ConnectionParameters);
}
// write arguments
foreach (var arg in methodCall.Parameters)
{
writer.WriteAmfItem(encoding, arg);
}
}
public static Task WriteAsync(Stream stream, RtmpHandshake h, bool writeVersion)
{
using (MemoryStream memoryStream = new MemoryStream())
{
using (AmfWriter amfWriter = new AmfWriter((Stream)memoryStream, (SerializationContext)null))
{
if (writeVersion)
{
amfWriter.WriteByte(h.Version);
}
amfWriter.WriteUInt32(h.Time);
amfWriter.WriteUInt32(h.Time2);
amfWriter.WriteBytes(h.Random);
byte[] array = memoryStream.ToArray();
return(stream.WriteAsync(array, 0, array.Length));
}
}
}
public static void WriteTo(AmfWriter writer, Type type, ChunkStream.Snapshot stream)
{
var extendTs = stream.Timestamp >= ExtendedTimestampSentinel;
var inlineTs = extendTs ? ExtendedTimestampSentinel : stream.Timestamp;
switch (type)
{
case Type.Type0:
writer.WriteUInt24((uint)inlineTs);
writer.WriteUInt24((uint)stream.MessageLength);
writer.WriteByte((byte)stream.ContentType);
writer.WriteLittleEndianInt(stream.MessageStreamId);
if (extendTs)
{
writer.WriteUInt32(stream.Timestamp);
}
break;
case Type.Type1:
writer.WriteUInt24((uint)inlineTs);
writer.WriteUInt24((uint)stream.MessageLength);
writer.WriteByte((byte)stream.ContentType);
if (extendTs)
{
writer.WriteUInt32(stream.Timestamp);
}
break;
case Type.Type2:
writer.WriteUInt24((uint)inlineTs);
if (extendTs)
{
writer.WriteUInt32(stream.Timestamp);
}
break;
case Type.Type3:
break;
default:
throw new ArgumentOutOfRangeException(nameof(type));
}
}
public void WriteData(AmfWriter writer, object obj)
{
IDictionary <string, object> dictionary;
IEnumerable enumerable;
if ((dictionary = obj as IDictionary <string, object>) != null)
{
// method writes type marker
writer.WriteAmf0AssociativeArray(dictionary);
}
else if ((enumerable = obj as IEnumerable) != null)
{
writer.WriteMarker(Amf0TypeMarkers.StrictArray);
writer.WriteAmf0Array(enumerable.Cast <object>().ToArray());
}
else
{
// method writes type marker
writer.WriteAmf0TypedObject(obj);
}
}
public void WriteData(AmfWriter writer, object obj)
{
IDictionary<string, object> dictionary;
IEnumerable enumerable;
if ((dictionary = obj as IDictionary<string, object>) != null)
{
// method writes type marker
writer.WriteAmf0AssociativeArray(dictionary);
}
else if ((enumerable = obj as IEnumerable) != null)
{
writer.WriteMarker(Amf0TypeMarkers.StrictArray);
writer.WriteAmf0Array(enumerable.Cast<object>().ToArray());
}
else
{
// method writes type marker
writer.WriteAmf0TypedObject(obj);
}
}
public void ApplyValues()
{
var writer = new AmfWriter();
writer.WriteString("connect");
writer.WriteNumber(TransactionId);
var obj = new AmfObject();
obj.Strings.Add("app", App);
obj.Strings.Add("flashver", FlashVersion);
obj.Strings.Add("swfUrl", SwfUrl);
obj.Strings.Add("tcUrl", ServerUrl);
obj.Booleans.Add("fpad", Proxy);
obj.Numbers.Add("audioCodecs", AudioCodecs);
obj.Numbers.Add("videoCodecs", VideoCodecs);
obj.Numbers.Add("videoFunction", VideoFunction);
obj.Strings.Add("pageUrl", PageUrl);
obj.Numbers.Add("objectEncoding", ObjectEncoding);
writer.WriteObject(obj);
Data = writer.GetByteArray();
}
public void WriteData(AmfWriter writer, object obj)
{
IDictionary <string, object> dictionary;
if ((dictionary = obj as IDictionary <string, object>) != null)
{
writer.WriteAmf0AssociativeArray(dictionary);
}
else
{
IEnumerable source;
if ((source = obj as IEnumerable) != null)
{
writer.WriteMarker(Amf0TypeMarkers.StrictArray);
writer.WriteAmf0Array((Array)source.Cast <object>().ToArray <object>());
}
else
{
writer.WriteAmf0TypedObject(obj);
}
}
}
// most rtmp servers we are interested in only support amf3 via an amf0 envelope
static void WriteCommand(ObjectEncoding encoding, AmfWriter w, RtmpMessage message)
{
switch (message)
{
case Notify notify:
w.WriteBoxedAmf0Object(encoding, notify.Data);
break;
case Invoke request:
w.WriteBoxedAmf0Object(encoding, request.MethodName);
w.WriteBoxedAmf0Object(encoding, request.InvokeId);
w.WriteBoxedAmf0Object(encoding, request.Headers);
foreach (var arg in request.Arguments ?? EmptyArray <object> .Instance)
{
w.WriteBoxedAmf0Object(encoding, arg);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
byte[] GetMessageBytes(RtmpEvent message, Action<AmfWriter, RtmpEvent> handler)
{
using (var stream = new MemoryStream())
using (var messageWriter = new AmfWriter(stream, writer.SerializationContext, objectEncoding))
{
handler(messageWriter, message);
return stream.ToArray();
}
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteAmf0StringSpecial(obj as string);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteAmf0AsObject(obj as AsObject);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf0TypeMarkers.Number);
writer.WriteDouble(Convert.ToDouble(obj));
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.Integer);
writer.WriteAmf3Int(Convert.ToInt32(obj));
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf0TypeMarkers.Boolean);
writer.WriteBoolean((bool)obj);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteAmf3NumberSpecial(Convert.ToInt32(obj));
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.Array);
writer.WriteAmf3Array(obj as Array);
}
public byte[] Encode()
{
using (var ms = new MemoryStream())
{
var aw = new AmfWriter(ms);
aw.Write(CommandName);
int transid = 0;
switch (transid)
{
case -2:
transid = CurrentTransactionID++;
break;
case -1:
transid = 0;
break;
default:
transid = TransactionID;
break;
}
aw.Write(transid);
aw.Write(CommandObject);
if (Arguments != null)
{
Arguments.ForEach(aw.Write);
}
return ms.ToArray();
}
}
/// <summary>
/// This method supports the Fluorine infrastructure and is not intended to be used directly from your code.
/// </summary>
protected virtual void WriteBodyData(ObjectEncoding objectEncoding, AmfWriter writer)
{
object content = this.Content;
writer.WriteAmfItem(objectEncoding, content);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf0TypeMarkers.Xml);
writer.WriteAmf0XDocument(obj as XDocument);
}
void WriteCommandOrData(AmfWriter writer, RtmpEvent o, ObjectEncoding encoding)
{
var command = o as Command;
var methodCall = command.MethodCall;
var isInvoke = command is Invoke;
// write the method name or result type (first section)
var isRequest = methodCall.CallStatus == CallStatus.Request;
if (isRequest)
writer.WriteAmfItem(encoding, methodCall.Name);
else
writer.WriteAmfItem(encoding, methodCall.IsSuccess ? "_result" : "_error");
if (isInvoke)
{
writer.WriteAmfItem(encoding, command.InvokeId);
writer.WriteAmfItem(encoding, command.ConnectionParameters);
}
if (isRequest)
{
// write arguments
foreach (var arg in methodCall.Parameters)
writer.WriteAmfItem(encoding, arg);
}
else if (isInvoke)
{
// write the result
if (!methodCall.IsSuccess)
methodCall.Parameters = new object[] { new StatusAsObject(StatusCode.CallFailed, "error", "Call failed.") };
writer.WriteAmfItem(encoding, methodCall.Parameters);
}
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.String);
writer.WriteAmf3Utf(obj as string);
}
void WriteData(AmfWriter writer, RtmpEvent o, ObjectEncoding encoding)
{
var command = o as Command;
if (command.MethodCall == null)
WriteCommandOrData(writer, o, encoding);
else
writer.WriteBytes(command.Buffer);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf0TypeMarkers.String);
writer.WriteUtfPrefixed(((Guid)obj).ToString());
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf0TypeMarkers.Number);
writer.WriteDouble(Convert.ToDouble(obj));
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf0TypeMarkers.Date);
writer.WriteAmf0DateTime((DateTime)obj);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteAmf3BoolSpecial((bool)obj);
}
public DataOutput(AmfWriter writer)
{
this.writer = writer;
this.objectEncoding = ObjectEncoding.Amf3;
}
internal void WriteBody(ObjectEncoding objectEncoding, AmfWriter writer)
{
writer.Reset();
if (this.Target == null)
writer.WriteUtfPrefixed("null");
else
writer.WriteUtfPrefixed(this.Target);
if (this.Response == null)
writer.WriteUtfPrefixed("null");
else
writer.WriteUtfPrefixed(this.Response);
writer.WriteInt32(-1);
WriteBodyData(objectEncoding, writer);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.ByteArray);
// We're just writing a plain byte array, so we don't need a serialization context
writer.WriteAmf3ByteArray(new ByteArray((byte[])obj, null));
}
public DataOutput(AmfWriter writer)
{
this._writer = writer;
this.ObjectEncoding = ObjectEncoding.Amf3;
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.Xml);
writer.WriteAmf3XElement(obj as XElement);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.Xml);
writer.WriteAmf3XElement(obj as XElement);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.Object);
writer.WriteAmf3Object(obj);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.String);
writer.WriteAmf3Utf(obj as string);
}
public void WriteData(AmfWriter writer, object obj)
{
writer.WriteMarker(Amf3TypeMarkers.String);
writer.WriteAmf3Utf(((Guid)obj).ToString());
}
