public bool Link(IOutStream pOutStream, bool reverseLink = true)
{
if (!pOutStream.IsCompatibleWithType(Type) || !IsCompatibleWithType(pOutStream.Type))
{
Logger.FATAL("stream type {0} not compatible with stream type {1}", Type.TagToString(), pOutStream.Type.TagToString());
return(false);
}
if (OutStreams.Contains(pOutStream))
{
Logger.WARN("BaseInStream::Link: This stream is already linked");
return(true);
}
OutStreams.Add(pOutStream);
if (reverseLink)
{
if (!pOutStream.Link(this, false))
{
Logger.FATAL("BaseInStream::Link: Unable to reverse link");
//NYIA;
return(false);
}
}
SignalOutStreamAttached(pOutStream);
return(true);
}
void FeedVideoCodecSetup(IOutStream pOutStream)
{
if (!pOutStream.FeedData(
Utils.Rms.GetStream("sps", Capabilities.Avc.SPS, 0, Capabilities.Avc.SPS.Length),
Capabilities.Avc.SpsLength,
0,
Capabilities.Avc.SpsLength,
_videoLastTs,
false))
{
FATAL("Unable to feed stream");
if (pOutStream.GetProtocol() != null)
{
pOutStream.GetProtocol().EnqueueForDelete();
}
}
if (!pOutStream.FeedData(
Utils.Rms.GetStream("pps", Capabilities.Avc.PPS, 0, Capabilities.Avc.PPS.Length),
Capabilities.Avc.PpsLength,
0,
Capabilities.Avc.PpsLength,
_videoLastTs,
false))
{
FATAL("Unable to feed stream");
if (pOutStream.GetProtocol() != null)
{
pOutStream.GetProtocol().EnqueueForDelete();
}
}
}
public override void SignalOutStreamAttached(IOutStream pOutStream)
{
base.SignalOutStreamAttached(pOutStream);
if (_hasVideo && _hasAudio)
{
if (_videoLastTs != 0 && _audioLastTs != 0 && _videoLastTs < _audioLastTs)
{
FeedVideoCodecSetup(pOutStream);
FeedAudioCodecSetup(pOutStream);
_avCodecsSent = true;
}
}
else
{
if (_videoLastTs != 0)
{
FeedVideoCodecSetup(pOutStream);
_avCodecsSent = true;
}
if (_audioLastTs != 0)
{
FeedAudioCodecSetup(pOutStream);
_avCodecsSent = true;
}
}
}
public bool UnLink(IOutStream pOutStream)
{
OutStreams.Remove(pOutStream);
OnFeedData -= pOutStream.FeedData;
OnSendStreamMessage -= pOutStream.SendStreamMessage;
SignalOutStreamDetached(pOutStream);
return(true);
}
public static void AssignFrom <T>(this IOutStream <T> outStream, IEnumerable <T> source)
{
using (var writer = outStream.GetDynamicWriter())
foreach (var entry in source)
{
writer.Write(entry);
}
}
public override void SignalOutStreamAttached(IOutStream pOutStream)
{
base.SignalOutStreamAttached(pOutStream);
foreach (var buffer in StreamMessageBuffer)
{
pOutStream.SendStreamMessage(buffer);
}
}
public OutputBinSpreadStream(IIOFactory ioFactory, OutputAttribute attribute)
{
FDataContainer = ioFactory.CreateIOContainer <IOutStream <T> >(attribute, false);
FBinSizeContainer = ioFactory.CreateIOContainer <IOutStream <int> >(attribute.GetBinSizeOutputAttribute(), false);
FDataStream = FDataContainer.IOObject;
FBinSizeStream = FBinSizeContainer.IOObject;
Length = 1;
}
public MultiDimOutStream(IIOFactory ioFactory, OutputAttribute attribute)
{
FDataContainer = ioFactory.CreateIOContainer <IOutStream <T> >(attribute.DecreaseBinSizeWrapCount(), false);
FBinSizeContainer = ioFactory.CreateIOContainer <IOutStream <int> >(attribute.GetBinSizeOutputAttribute(FDataContainer), false);
FDataStream = FDataContainer.IOObject;
FBinSizeStream = FBinSizeContainer.IOObject;
Length = 1;
}
public virtual void SignalOutStreamDetached(IOutStream pOutStream)
{
var stream = pOutStream as OutNetRtmfpStream;
if (stream != null)
{
OnFlush -= stream.Flush;
}
}
public static void AssignFrom <T>(this IOutStream <T> outStream, IReadOnlyCollection <T> source)
{
outStream.Length = source.Count;
using (var writer = outStream.GetWriter())
foreach (var entry in source)
{
writer.Write(entry);
}
}
public static void Append<T>(this IOutStream<T> outStream, IInStream<T> inStream, T[] buffer)
{
var initialOutLength = outStream.Length;
outStream.Length += inStream.Length;
using (var writer = outStream.GetWriter())
{
writer.Position = initialOutLength;
writer.Write(inStream, buffer);
}
}
//public override bool IsCompatibleWithType(ulong type)
//{
// return type.TagKindOf(StreamTypes.ST_OUT_NET_RTMP);
//}
public override void SignalOutStreamAttached(IOutStream pOutStream)
{
//2. Set a big chunk size on the corresponding connection
if (pOutStream.Type.TagKindOf(ST_OUT_NET_RTMP))
{
((BaseOutNetRTMPStream)pOutStream).TrySetOutboundChunkSize(ChunkSize);
}
base.SignalOutStreamAttached(pOutStream);
((IInFileRTMPStreamHolder)Protocol).OnReadyForSend += ReadyForSend;
}
public override void SignalOutStreamDetached(IOutStream pOutStream)
{
base.SignalOutStreamDetached(pOutStream);
((IInFileRTMPStreamHolder)Protocol).OnReadyForSend -= ReadyForSend;
FINEST("outbound stream {0} detached from inbound stream {1}", pOutStream.UniqueId, UniqueId);
if (OutStreams.Count == 0)
{
Dispose();
}
}
public static void Append<T>(this IOutStream<T> outStream, IInStream<T> inStream)
{
var buffer = MemoryPool<T>.GetArray();
try
{
outStream.Append(inStream, buffer);
}
finally
{
MemoryPool<T>.PutArray(buffer);
}
}
public virtual void SignalOutStreamAttached(IOutStream pOutStream)
{
OnFeedData += pOutStream.FeedData;
OnSendStreamMessage += pOutStream.SendStreamMessage;
var stream = pOutStream as OutNetRtmfpStream;
if (stream != null)
{
OnFlush += stream.Flush;
}
}
public override void SignalOutStreamDetached(IOutStream pOutStream)
{
if (OutStreams.Count == 0)
{
Protocol.Send(ClusterMessageType.NoSubscriber, o =>
{
o.Write7BitValue(AppId);
o.Write(Name);
});
Dispose();
}
base.SignalOutStreamDetached(pOutStream);
}
public static void AssignFrom <T>(this IOutStream <T> outStream, IInStream <T> inStream, T[] buffer)
{
outStream.Length = inStream.Length;
using (var reader = inStream.GetReader())
using (var writer = outStream.GetWriter())
{
while (!reader.Eos)
{
int numSlicesRead = reader.Read(buffer, 0, buffer.Length);
writer.Write(buffer, 0, numSlicesRead);
}
}
}
public OutputBinSpreadStream(IIOFactory ioFactory, OutputAttribute attribute, Func <IIOContainer, IIOContainer <IOutStream <int> > > binSizeIOContainerFactory)
{
if (attribute.IsBinSizeEnabled)
{
var container = ioFactory.CreateIOContainer <ISpread <T> >(attribute.DecreaseBinSizeWrapCount(), false); // Ask for a spread, otherwise we lose track of bin size wrapping
FDataContainer = container;
FDataStream = container.IOObject.Stream;
}
else
{
var container = ioFactory.CreateIOContainer <IOutStream <T> >(attribute, false); // No need for another indirection, access the node output directly
FDataContainer = container;
FDataStream = container.IOObject;
}
FBinSizeContainer = binSizeIOContainerFactory(FDataContainer);
FBinSizeStream = FBinSizeContainer.IOObject;
Length = 1;
}
void FeedAudioCodecSetup(IOutStream pOutStream)
{
if (Capabilities.AudioCodecId == AudioCodec.Aac)
{
if (!pOutStream.FeedData(
Utils.Rms.GetStream("aac", Capabilities.Aac._pAAC, 0, Capabilities.Aac._pAAC.Length),
Capabilities.Aac._aacLength,
0,
Capabilities.Aac._aacLength,
_audioLastTs,
true))
{
FATAL("Unable to feed stream");
if (pOutStream.GetProtocol() != null)
{
pOutStream.GetProtocol().EnqueueForDelete();
}
}
}
}
public override void SignalOutStreamAttached(IOutStream pOutStream)
{
if (_videoCodecInit.Length > 0 &&
!pOutStream.FeedData(_videoCodecInit, (uint)_videoCodecInit.Length, 0, (uint)_videoCodecInit.Length, _lastVideoTime, false))
{
this.Log().Info("Unable to feed OS: {0}", pOutStream.UniqueId);
pOutStream.EnqueueForDelete();
}
if (_audioCodecInit.Length > 0 &&
!pOutStream.FeedData(_audioCodecInit, (uint)_audioCodecInit.Length, 0, (uint)_audioCodecInit.Length, _lastAudioTime, true))
{
this.Log().Info("Unable to feed OS: {0}", pOutStream.UniqueId);
pOutStream.EnqueueForDelete();
}
//if (_lastStreamMessage != null &&pOutStream.Type.TagKindOf(StreamTypes.ST_OUT_NET_RTMP))
//{
// (pOutStream as IOutNetStream).SendStreamMessage(_lastStreamMessage.Value.Body, _lastStreamMessage.Value.MessageLength);
//}
base.SignalOutStreamAttached(pOutStream);
}
public static void AssignFrom <T>(this IOutStream <T> outStream, IInStream <T> inStream)
{
if (inStream.Length != 1)
{
var buffer = MemoryPool <T> .GetArray();
try
{
outStream.AssignFrom(inStream, buffer);
}
finally
{
MemoryPool <T> .PutArray(buffer);
}
}
else
{
outStream.Length = 1;
using (var reader = inStream.GetReader())
using (var writer = outStream.GetWriter())
writer.Write(reader.Read());
}
}
//public override bool IsCompatibleWithType(ulong type)
//{
// return type.TagKindOf(StreamTypes.ST_OUT_NET_RTMP_4_RTMP)
// || type.TagKindOf(StreamTypes.ST_OUT_NET_RTMFP)
// || type.TagKindOf(StreamTypes.ST_OUT_FILE_RTMP)
// || type.TagKindOf(StreamTypes.ST_OUT_NET_RTP)
// || type.TagKindOf(StreamTypes.ST_OUT_FILE_HLS);
//}
public override void SignalOutStreamAttached(IOutStream pOutStream)
{
if (VideoCodecBuffer.Length > 0 &&
!pOutStream.FeedData(VideoCodecBuffer, (uint)VideoCodecBuffer.Length, 0, (uint)VideoCodecBuffer.Length, _lastVideoTime, false))
{
this.Log().Info("Unable to feed OS: {0}", pOutStream.UniqueId);
pOutStream.EnqueueForDelete();
}
if (AudioCodecBuffer.Length > 0 &&
!pOutStream.FeedData(AudioCodecBuffer, (uint)AudioCodecBuffer.Length, 0, (uint)AudioCodecBuffer.Length, _lastAudioTime, false))
{
this.Log().Info("Unable to feed OS: {0}", pOutStream.UniqueId);
pOutStream.EnqueueForDelete();
}
//if (_lastStreamMessage != null
// && pOutStream.Type.TagKindOf(StreamTypes.ST_OUT_NET_RTMP)
// && !(pOutStream as BaseOutNetRTMPStream).SendStreamMessage(_lastStreamMessage))
//{
// Logger.FATAL("Unable to send notify on stream. The connection will go down");
// pOutStream.EnqueueForDelete();
//}
base.SignalOutStreamAttached(pOutStream);
}
public void PrintNumber(BitsConst radix, IOutStream outStream)
{
var r = radix.ToInt64();
if(radix.Size.IsZero)
r = 10;
var left = ToString((int) r);
outStream.AddData(left);
}
public UnknownStackData(Size size, IOutStream outStream)
: base(outStream)
{
Size = size;
}
public void PrintText(Size itemSize, IOutStream outStream)
=> outStream.AddData(ToString(itemSize));
public void PrintNumber(IOutStream outStream) => PrintNumber(None(), outStream);
//public override bool IsCompatibleWithType(ulong type)
//{
// return type.TagKindOf(StreamTypes.ST_OUT_NET_RTMP);
//}
public override void SignalOutStreamAttached(IOutStream pOutStream)
{
//2. Set a big chunk size on the corresponding connection
if (pOutStream.Type.TagKindOf(ST_OUT_NET_RTMP))
{
((BaseOutNetRTMPStream)pOutStream).TrySetOutboundChunkSize(ChunkSize);
}
base.SignalOutStreamAttached(pOutStream);
((IInFileRTMPStreamHolder)Protocol).OnReadyForSend += ReadyForSend;
}
internal EmptyStackData(IOutStream outStream)
: base(outStream) { }
void AssignStream <T>(IInStream <T> source, IOutStream <T> dest)
{
dest.AssignFrom(source);
}
public static BufferedStreamWriter <T> GetBufferedWriter <T>(this IOutStream <T> stream)
{
return(new BufferedStreamWriter <T>(stream));
}
public static DynamicStreamWriter <T> GetDynamicWriter <T>(this IOutStream <T> stream)
{
return(new DynamicStreamWriter <T>(stream));
}
public BufferedOutputIOStream(IOutStream <T> outStream)
{
FOutStream = outStream;
}
ListStack(NonListStackData[] data, IOutStream outStream)
: base(outStream)
{
_data = data;
}
protected NonListStackData(IOutStream outStream)
: base(outStream) {}
public override void SignalOutStreamDetached(IOutStream pOutStream)
{
base.SignalOutStreamDetached(pOutStream);
((IInFileRTMPStreamHolder)Protocol).OnReadyForSend -= ReadyForSend;
FINEST("outbound stream {0} detached from inbound stream {1}",pOutStream.UniqueId,UniqueId);
if (OutStreams.Count == 0)
{
Dispose();
}
}
protected StackData(IOutStream outStream) { OutStream = outStream; }
public BitsStackData(BitsConst data, IOutStream outStream)
: base(outStream)
{
_data = data;
Tracer.Assert(!_data.Size.IsZero);
}
public StreamThread(StreamKind kind, IOutStream target)
{
Kind = kind;
Target = target;
}
public LocalData(IOutStream outStream) { Data = new EmptyStackData(outStream); }
public OutputPin(IIOFactory factory, IPluginOut pluginOut, IOutStream <T> outStream)
: this(factory, pluginOut, new BufferedOutputIOStream <T>(outStream))
{
}
internal BufferedStreamWriter(IOutStream <T> stream)
{
FStreamWriter = stream.GetWriter();
FBuffer = MemoryPool <T> .GetArray();
}
public static void SetLengthBy <T>(this IOutStream <T> outStream, IInStream <IInStream <T> > inputStreams)
{
outStream.Length = inputStreams.GetMaxLength() * inputStreams.Length;
}
public StackDataAddress(IStackDataAddressBase data, Size offset, IOutStream outStream)
: base(outStream)
{
_data = data;
_offset = offset;
}
