public void seek(double position) { IConnection connection = FluorineContext.Current.Connection; if (connection is IStreamCapableConnection) { IStreamCapableConnection connection2 = connection as IStreamCapableConnection; int currentStreamId = this.GetCurrentStreamId(); IClientStream streamById = connection2.GetStreamById(currentStreamId); if ((streamById != null) && (streamById is ISubscriberStream)) { ISubscriberStream stream2 = streamById as ISubscriberStream; try { stream2.Seek((int)position); } catch (NotSupportedException exception) { StatusASO status = new StatusASO("NetStream.Seek.Failed") { clientid = currentStreamId, description = "The stream doesn't support seeking.", level = "error", details = exception.Message }; (connection2 as RtmpConnection).GetChannel((byte)(4 + ((currentStreamId - 1) * 5))).SendStatus(status); } } } }
public void seek(double position) { IConnection connection = FluorineContext.Current.Connection; if (!(connection is IStreamCapableConnection)) { return; } IStreamCapableConnection streamConnection = connection as IStreamCapableConnection; int streamId = GetCurrentStreamId(); IClientStream stream = streamConnection.GetStreamById(streamId); if (stream == null || !(stream is ISubscriberStream)) { return; } ISubscriberStream subscriberStream = stream as ISubscriberStream; try { subscriberStream.Seek((int)position); } catch (NotSupportedException ex) { StatusASO seekFailed = new StatusASO(StatusASO.NS_SEEK_FAILED); seekFailed.clientid = streamId; seekFailed.description = "The stream doesn't support seeking."; seekFailed.level = "error"; seekFailed.details = ex.Message; // FIXME: there should be a direct way to send the status RtmpChannel channel = (streamConnection as RtmpConnection).GetChannel((byte)(4 + ((streamId - 1) * 5))); channel.SendStatus(seekFailed); } }
public void pause(bool pausePlayback, double position) { IConnection connection = FluorineContext.Current.Connection; if (!(connection is IStreamCapableConnection)) { return; } IStreamCapableConnection streamConnection = connection as IStreamCapableConnection; int streamId = GetCurrentStreamId(); IClientStream stream = streamConnection.GetStreamById(streamId); if (stream == null || !(stream is ISubscriberStream)) { return; } ISubscriberStream subscriberStream = stream as ISubscriberStream; if (pausePlayback) { subscriberStream.Pause((int)position); } else { subscriberStream.Resume((int)position); } }
public void publish(bool dontStop) { if (!dontStop) { IConnection connection = FluorineContext.Current.Connection; if (connection is IStreamCapableConnection) { IStreamCapableConnection connection2 = connection as IStreamCapableConnection; int currentStreamId = this.GetCurrentStreamId(); IClientStream streamById = connection2.GetStreamById(currentStreamId); if (streamById is IBroadcastStream) { IBroadcastStream stream2 = streamById as IBroadcastStream; if (stream2.PublishedName != null) { IBroadcastScope broadcastScope = this.GetBroadcastScope(connection.Scope, stream2.PublishedName); if (broadcastScope != null) { broadcastScope.Unsubscribe(stream2.Provider); if (connection is BaseConnection) { (connection as BaseConnection).UnregisterBasicScope(broadcastScope); } } stream2.Close(); connection2.DeleteStreamById(currentStreamId); } } } } }
public void publish(bool dontStop) { if (!dontStop) { IConnection connection = FluorineContext.Current.Connection; if (!(connection is IStreamCapableConnection)) { return; } IStreamCapableConnection streamConnection = connection as IStreamCapableConnection; int streamId = GetCurrentStreamId(); IClientStream stream = streamConnection.GetStreamById(streamId); if (!(stream is IBroadcastStream)) { return; } IBroadcastStream bs = stream as IBroadcastStream; if (bs.PublishedName == null) { return; } IBroadcastScope bsScope = GetBroadcastScope(connection.Scope, bs.PublishedName); if (bsScope != null) { bsScope.Unsubscribe(bs.Provider); if (connection is BaseConnection) { (connection as BaseConnection).UnregisterBasicScope(bsScope); } } bs.Close(); streamConnection.DeleteStreamById(streamId); } }
public void deleteStream(IStreamCapableConnection connection, int streamId) { IClientStream stream = connection.GetStreamById(streamId); if (stream != null) { if (stream is IClientBroadcastStream) { IClientBroadcastStream bs = stream as IClientBroadcastStream; IBroadcastScope bsScope = GetBroadcastScope(connection.Scope, bs.PublishedName); if (bsScope != null && connection is BaseConnection) { (connection as BaseConnection).UnregisterBasicScope(bsScope); } } stream.Close(); } connection.UnreserveStreamId(streamId); }
public void receiveVideo(bool receive) { IConnection connection = FluorineContext.Current.Connection; if (connection is IStreamCapableConnection) { IStreamCapableConnection connection2 = connection as IStreamCapableConnection; int currentStreamId = this.GetCurrentStreamId(); IClientStream streamById = connection2.GetStreamById(currentStreamId); if ((streamById != null) && (streamById is ISubscriberStream)) { (streamById as ISubscriberStream).ReceiveVideo(receive); } } }
public void play(bool dontStop) { if (!dontStop) { IConnection connection = FluorineContext.Current.Connection; if (connection is IStreamCapableConnection) { IStreamCapableConnection connection2 = connection as IStreamCapableConnection; int currentStreamId = this.GetCurrentStreamId(); IClientStream streamById = connection2.GetStreamById(currentStreamId); if (streamById != null) { streamById.Stop(); } } } }
public void play(bool dontStop) { if (!dontStop) { IConnection connection = FluorineContext.Current.Connection; if (!(connection is IStreamCapableConnection)) { return; } IStreamCapableConnection streamConnection = connection as IStreamCapableConnection; int streamId = GetCurrentStreamId(); IClientStream stream = streamConnection.GetStreamById(streamId); if (stream != null) { stream.Stop(); } } }
public void deleteStream(IStreamCapableConnection connection, int streamId) { IClientStream streamById = connection.GetStreamById(streamId); if (streamById != null) { if (streamById is IClientBroadcastStream) { IClientBroadcastStream stream2 = streamById as IClientBroadcastStream; IBroadcastScope broadcastScope = this.GetBroadcastScope(connection.Scope, stream2.PublishedName); if ((broadcastScope != null) && (connection is BaseConnection)) { (connection as BaseConnection).UnregisterBasicScope(broadcastScope); } } streamById.Close(); } connection.UnreserveStreamId(streamId); }
public void deleteStream(IStreamCapableConnection connection, int streamId) { IClientStream stream = connection.GetStreamById(streamId); if (stream != null) { if (stream is IClientBroadcastStream) { IClientBroadcastStream bs = stream as IClientBroadcastStream; IBroadcastScope bsScope = GetBroadcastScope(connection.Scope, bs.PublishedName); if (bsScope != null && connection is BaseConnection) { (connection as BaseConnection).UnregisterBasicScope(bsScope); } } stream.Close(); } connection.UnreserveStreamId(streamId); }
public void receiveAudio(bool receive) { IConnection connection = FluorineContext.Current.Connection; if (!(connection is IStreamCapableConnection)) { return; } IStreamCapableConnection streamConnection = connection as IStreamCapableConnection; int streamId = GetCurrentStreamId(); IClientStream stream = streamConnection.GetStreamById(streamId); if (stream == null || !(stream is ISubscriberStream)) { return; } ISubscriberStream subscriberStream = stream as ISubscriberStream; subscriberStream.ReceiveAudio(receive); }
public void pause(bool pausePlayback, double position) { IConnection connection = FluorineContext.Current.Connection; if (connection is IStreamCapableConnection) { IStreamCapableConnection connection2 = connection as IStreamCapableConnection; int currentStreamId = this.GetCurrentStreamId(); IClientStream streamById = connection2.GetStreamById(currentStreamId); if ((streamById != null) && (streamById is ISubscriberStream)) { ISubscriberStream stream2 = streamById as ISubscriberStream; if (pausePlayback) { stream2.Pause((int)position); } else { stream2.Resume((int)position); } } } }
public void publish(string name, string mode) { IConnection connection = FluorineContext.Current.Connection; if (connection is IStreamCapableConnection) { IStreamCapableConnection connection2 = connection as IStreamCapableConnection; IScope scope = connection.Scope; int currentStreamId = this.GetCurrentStreamId(); if ((name == null) || string.Empty.Equals(name)) { this.SendNSFailed(connection2 as RtmpConnection, "The stream name may not be empty.", name, currentStreamId); } else { IStreamSecurityService scopeService = ScopeUtils.GetScopeService(scope, typeof(IStreamSecurityService)) as IStreamSecurityService; if (scopeService != null) { IEnumerator streamPublishSecurity = scopeService.GetStreamPublishSecurity(); while (streamPublishSecurity.MoveNext()) { IStreamPublishSecurity current = streamPublishSecurity.Current as IStreamPublishSecurity; if (!current.IsPublishAllowed(scope, name, mode)) { this.SendNSFailed(connection2 as RtmpConnection, "You are not allowed to publish the stream.", name, currentStreamId); return; } } } IBroadcastScope broadcastScope = this.GetBroadcastScope(scope, name); if ((broadcastScope != null) && (broadcastScope.GetProviders().Count > 0)) { StatusASO status = new StatusASO("NetStream.Publish.BadName") { clientid = currentStreamId, details = name, level = "error" }; (connection2 as RtmpConnection).GetChannel((byte)(4 + ((currentStreamId - 1) * 5))).SendStatus(status); } else { IClientStream streamById = connection2.GetStreamById(currentStreamId); if ((streamById == null) || (streamById is IClientBroadcastStream)) { bool flag = false; if (streamById == null) { streamById = connection2.NewBroadcastStream(currentStreamId); flag = true; } IClientBroadcastStream broadcastStream = streamById as IClientBroadcastStream; try { broadcastStream.PublishedName = name; IScopeContext context = connection.Scope.Context; IProviderService service2 = ScopeUtils.GetScopeService(connection.Scope, typeof(IProviderService)) as IProviderService; if (service2.RegisterBroadcastStream(connection.Scope, name, broadcastStream)) { broadcastScope = this.GetBroadcastScope(connection.Scope, name); broadcastScope.SetAttribute("_transient_publishing_stream", broadcastStream); if (connection is BaseConnection) { (connection as BaseConnection).RegisterBasicScope(broadcastScope); } } if ("record".Equals(mode)) { broadcastStream.Start(); broadcastStream.SaveAs(name, false); } else if ("append".Equals(mode)) { broadcastStream.Start(); broadcastStream.SaveAs(name, true); } else if ("live".Equals(mode)) { broadcastStream.Start(); } broadcastStream.StartPublishing(); } catch (IOException exception) { StatusASO saso2 = new StatusASO("NetStream.Record.NoAccess") { clientid = currentStreamId, description = "The file could not be created/written to." + exception.Message, details = name, level = "error" }; (connection2 as RtmpConnection).GetChannel((byte)(4 + ((currentStreamId - 1) * 5))).SendStatus(saso2); broadcastStream.Close(); if (flag) { connection2.DeleteStreamById(currentStreamId); } } catch (Exception exception2) { log.Warn("Publish caught exception", exception2); } } } } } }
public void publish(string name, string mode) { IConnection connection = FluorineContext.Current.Connection; if (!(connection is IStreamCapableConnection)) { return; } IStreamCapableConnection streamConnection = connection as IStreamCapableConnection; IScope scope = connection.Scope; int streamId = GetCurrentStreamId(); if (name == null || string.Empty.Equals(name)) { SendNSFailed(streamConnection as RtmpConnection, "The stream name may not be empty.", name, streamId); return; } IStreamSecurityService security = ScopeUtils.GetScopeService(scope, typeof(IStreamSecurityService)) as IStreamSecurityService; if (security != null) { IEnumerator handlers = security.GetStreamPublishSecurity(); while (handlers.MoveNext()) { IStreamPublishSecurity handler = handlers.Current as IStreamPublishSecurity; if (!handler.IsPublishAllowed(scope, name, mode)) { SendNSFailed(streamConnection as RtmpConnection, "You are not allowed to publish the stream.", name, streamId); return; } } } IBroadcastScope bsScope = GetBroadcastScope(scope, name); if (bsScope != null && bsScope.GetProviders().Count > 0) { // Another stream with that name is already published. StatusASO badName = new StatusASO(StatusASO.NS_PUBLISH_BADNAME); badName.clientid = streamId; badName.details = name; badName.level = "error"; // FIXME: there should be a direct way to send the status RtmpChannel channel = (streamConnection as RtmpConnection).GetChannel((byte)(4 + ((streamId - 1) * 5))); channel.SendStatus(badName); return; } IClientStream stream = streamConnection.GetStreamById(streamId); if (stream != null && !(stream is IClientBroadcastStream)) { return; } bool created = false; if (stream == null) { stream = streamConnection.NewBroadcastStream(streamId); created = true; } IClientBroadcastStream bs = stream as IClientBroadcastStream; try { bs.PublishedName = name; IScopeContext context = connection.Scope.Context; //IProviderService providerService = (IProviderService)context.getBean(IProviderService.BEAN_NAME); IProviderService providerService = ScopeUtils.GetScopeService(connection.Scope, typeof(IProviderService)) as IProviderService; // TODO handle registration failure if (providerService.RegisterBroadcastStream(connection.Scope, name, bs)) { bsScope = GetBroadcastScope(connection.Scope, name); bsScope.SetAttribute(Constants.BroadcastScopeStreamAttribute, bs); if (connection is BaseConnection) { (connection as BaseConnection).RegisterBasicScope(bsScope); } } if (Constants.ClientStreamModeRecord.Equals(mode)) { bs.Start(); bs.SaveAs(name, false); } else if (Constants.ClientStreamModeAppend.Equals(mode)) { bs.Start(); bs.SaveAs(name, true); } else if (Constants.ClientStreamModeLive.Equals(mode)) { bs.Start(); } bs.StartPublishing(); } catch (System.IO.IOException ex) { StatusASO accessDenied = new StatusASO(StatusASO.NS_RECORD_NOACCESS); accessDenied.clientid = streamId; accessDenied.description = "The file could not be created/written to." + ex.Message; accessDenied.details = name; accessDenied.level = "error"; // FIXME: there should be a direct way to send the status RtmpChannel channel = (streamConnection as RtmpConnection).GetChannel((byte)(4 + ((streamId - 1) * 5))); channel.SendStatus(accessDenied); bs.Close(); if (created) { streamConnection.DeleteStreamById(streamId); } } catch (Exception ex) { log.Warn("Publish caught exception", ex); } }
public void play(string name, double start, double length, bool flushPlaylist) { IConnection connection = FluorineContext.Current.Connection; if (!(connection is IStreamCapableConnection)) { return; } IStreamCapableConnection streamConnection = connection as IStreamCapableConnection; IScope scope = connection.Scope; int streamId = GetCurrentStreamId(); if (name == null || string.Empty.Equals(name)) { SendNSFailed(streamConnection as RtmpConnection, "The stream name may not be empty.", name, streamId); return; } IStreamSecurityService security = ScopeUtils.GetScopeService(scope, typeof(IStreamSecurityService)) as IStreamSecurityService; if (security != null) { IEnumerator handlers = security.GetStreamPlaybackSecurity(); while (handlers.MoveNext()) { IStreamPlaybackSecurity handler = handlers.Current as IStreamPlaybackSecurity; if (!handler.IsPlaybackAllowed(scope, name, (long)start, (long)length, flushPlaylist)) { SendNSFailed(streamConnection as RtmpConnection, "You are not allowed to play the stream.", name, streamId); return; } } } IClientStream stream = streamConnection.GetStreamById(streamId); bool created = false; if (stream == null) { stream = streamConnection.NewPlaylistSubscriberStream(streamId); stream.Start(); created = true; } if (!(stream is ISubscriberStream)) { return; } ISubscriberStream subscriberStream = stream as ISubscriberStream; SimplePlayItem item = new SimplePlayItem(); item.Name = name; item.Start = (long)start; item.Length = (long)length; if (subscriberStream is IPlaylistSubscriberStream) { IPlaylistSubscriberStream playlistStream = subscriberStream as IPlaylistSubscriberStream; if (flushPlaylist) { playlistStream.RemoveAllItems(); } playlistStream.AddItem(item); } else if (subscriberStream is ISingleItemSubscriberStream) { ISingleItemSubscriberStream singleStream = subscriberStream as ISingleItemSubscriberStream; singleStream.PlayItem = item; } else { // not supported by this stream service return; } try { subscriberStream.Play(); } catch (System.IO.IOException ex) { if (created) { stream.Close(); streamConnection.DeleteStreamById(streamId); } SendNSFailed(streamConnection as RtmpConnection, ex.Message, name, streamId); } }
public void play(string name, double start, double length, bool flushPlaylist) { IConnection connection = FluorineContext.Current.Connection; if (connection is IStreamCapableConnection) { IStreamCapableConnection connection2 = connection as IStreamCapableConnection; IScope scope = connection.Scope; int currentStreamId = this.GetCurrentStreamId(); if ((name == null) || string.Empty.Equals(name)) { this.SendNSFailed(connection2 as RtmpConnection, "The stream name may not be empty.", name, currentStreamId); } else { IStreamSecurityService scopeService = ScopeUtils.GetScopeService(scope, typeof(IStreamSecurityService)) as IStreamSecurityService; if (scopeService != null) { IEnumerator streamPlaybackSecurity = scopeService.GetStreamPlaybackSecurity(); while (streamPlaybackSecurity.MoveNext()) { IStreamPlaybackSecurity current = streamPlaybackSecurity.Current as IStreamPlaybackSecurity; if (!current.IsPlaybackAllowed(scope, name, (long)start, (long)length, flushPlaylist)) { this.SendNSFailed(connection2 as RtmpConnection, "You are not allowed to play the stream.", name, currentStreamId); return; } } } IClientStream streamById = connection2.GetStreamById(currentStreamId); bool flag = false; if (streamById == null) { streamById = connection2.NewPlaylistSubscriberStream(currentStreamId); streamById.Start(); flag = true; } if (streamById is ISubscriberStream) { ISubscriberStream stream2 = streamById as ISubscriberStream; SimplePlayItem item = new SimplePlayItem { Name = name, Start = (long)start, Length = (long)length }; if (stream2 is IPlaylistSubscriberStream) { IPlaylistSubscriberStream stream3 = stream2 as IPlaylistSubscriberStream; if (flushPlaylist) { stream3.RemoveAllItems(); } stream3.AddItem(item); } else if (stream2 is ISingleItemSubscriberStream) { ISingleItemSubscriberStream stream4 = stream2 as ISingleItemSubscriberStream; stream4.PlayItem = item; } else { return; } try { stream2.Play(); } catch (IOException exception) { if (flag) { streamById.Close(); connection2.DeleteStreamById(currentStreamId); } this.SendNSFailed(connection2 as RtmpConnection, exception.Message, name, currentStreamId); } } } } }