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);
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; }