/** {@inheritDoc} */ public void seek(int position) { log.trace("seek - position:{}", position); IConnection conn = Red5.getConnectionLocal(); if (conn instanceof IStreamCapableConnection) { IStreamCapableConnection streamConn = (IStreamCapableConnection) conn; int streamId = conn.getStreamId(); IClientStream stream = streamConn.getStreamById(streamId); if (stream != null && stream instanceof ISubscriberStream) { ISubscriberStream subscriberStream = (ISubscriberStream) stream; try { subscriberStream.seek(position); } catch (OperationNotSupportedException err) { sendNSFailed( streamConn, StatusCodes.NS_SEEK_FAILED, "The stream doesn't support seeking.", stream.getName(), streamId); } } } }
/** * Dynamic streaming play method. * * <p>The following properties are supported on the play options: * * <pre> * streamName: String. The name of the stream to play or the new stream to switch to. * oldStreamName: String. The name of the initial stream that needs to be switched out. This is not needed and ignored * when play2 is used for just playing the stream and not switching to a new stream. * start: Number. The start time of the new stream to play, just as supported by the existing play API. and it has the * same defaults. This is ignored when the method is called for switching (in other words, the transition * is either NetStreamPlayTransition.SWITCH or NetStreamPlayTransitions.SWAP) * len: Number. The duration of the playback, just as supported by the existing play API and has the same defaults. * transition: String. The transition mode for the playback command. It could be one of the following: * NetStreamPlayTransitions.RESET * NetStreamPlayTransitions.APPEND * NetStreamPlayTransitions.SWITCH * NetStreamPlayTransitions.SWAP * </pre> * * NetStreamPlayTransitions: * * <pre> * APPEND : String = "append" - Adds the stream to a playlist and begins playback with the first stream. * APPEND_AND_WAIT : String = "appendAndWait" - Builds a playlist without starting to play it from the first stream. * RESET : String = "reset" - Clears any previous play calls and plays the specified stream immediately. * RESUME : String = "resume" - Requests data from the new connection starting from the point at which the previous connection ended. * STOP : String = "stop" - Stops playing the streams in a playlist. * SWAP : String = "swap" - Replaces a content stream with a different content stream and maintains the rest of the playlist. * SWITCH : String = "switch" - Switches from playing one stream to another stream, typically with streams of the same content. * </pre> * * @see <a * href="http://www.adobe.com/devnet/flashmediaserver/articles/dynstream_actionscript.html">ActionScript * guide to dynamic streaming</a> * @see <a * href="http://www.adobe.com/devnet/flashmediaserver/articles/dynstream_advanced_pt1.html">Dynamic * streaming in Flash Media Server - Part 1: Overview of the new capabilities</a> * @see <a * href="http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/NetStreamPlayTransitions.html">NetStreamPlayTransitions</a> * @param playOptions play options */ public void play2(Map<String, ?> playOptions) { log.debug("play2 options: {}", playOptions.toString()); /* { streamName=streams/new.flv, oldStreamName=streams/old.flv, start=0, len=-1, offset=12.195, transition=switch } */ // get the transition type String transition = (String) playOptions.get("transition"); String streamName = (String) playOptions.get("streamName"); String oldStreamName = (String) playOptions.get("oldStreamName"); // now initiate new playback int start = (Integer) playOptions.get("start"); int length = (Integer) playOptions.get("len"); // get the clients connection IConnection conn = Red5.getConnectionLocal(); if (conn != null && conn instanceof IStreamCapableConnection) { // get the stream id int streamId = conn.getStreamId(); IStreamCapableConnection streamConn = (IStreamCapableConnection) conn; if ("stop".equals(transition)) { play(Boolean.FALSE); } else if ("reset".equals(transition)) { // just reset the currently playing stream play(streamName); } else if ("switch".equals(transition)) { try { // set the playback type simplePlayback.set(Boolean.FALSE); // send the "start" of transition sendNSStatus( conn, StatusCodes.NS_PLAY_TRANSITION, String.format("Transitioning from %s to %s.", oldStreamName, streamName), streamName, streamId); // support offset? // playOptions.get("offset") play(streamName, start, length); } finally { // clean up simplePlayback.remove(); } } else if ("append".equals(transition) || "appendAndWait".equals(transition)) { IPlaylistSubscriberStream playlistStream = (IPlaylistSubscriberStream) streamConn.getStreamById(streamId); IPlayItem item = SimplePlayItem.build(streamName); playlistStream.addItem(item); if ("append".equals(transition)) { play(streamName, start, length, false); } } else if ("swap".equals(transition)) { IPlaylistSubscriberStream playlistStream = (IPlaylistSubscriberStream) streamConn.getStreamById(streamId); IPlayItem item = SimplePlayItem.build(streamName); int itemCount = playlistStream.getItemSize(); for (int i = 0; i < itemCount; i++) { IPlayItem tmpItem = playlistStream.getItem(i); if (tmpItem.getName().equals(oldStreamName)) { if (!playlistStream.replace(tmpItem, item)) { log.warn("Playlist item replacement failed"); sendNSFailed( streamConn, StatusCodes.NS_PLAY_FAILED, "Playlist swap failed.", streamName, streamId); } break; } } } else { log.warn("Unhandled transition: {}", transition); sendNSFailed( conn, StatusCodes.NS_FAILED, "Transition type not supported", streamName, streamId); } } else { log.info("Connection was null ?"); } }
/** {@inheritDoc} */ public void publish(String name, String mode) { Map<String, String> params = null; if (name != null && name.contains("?")) { // read and utilize the query string values params = new HashMap<String, String>(); String tmp = name; // check if we start with '?' or not if (name.charAt(0) != '?') { tmp = name.split("\\?")[1]; } else if (name.charAt(0) == '?') { tmp = name.substring(1); } // now break up into key/value blocks String[] kvs = tmp.split("&"); // take each key/value block and break into its key value parts for (String kv : kvs) { String[] split = kv.split("="); params.put(split[0], split[1]); } // grab the streams name name = name.substring(0, name.indexOf("?")); } log.debug("publish called with name {} and mode {}", name, mode); IConnection conn = Red5.getConnectionLocal(); if (conn instanceof IStreamCapableConnection) { IScope scope = conn.getScope(); IStreamCapableConnection streamConn = (IStreamCapableConnection) conn; int streamId = conn.getStreamId(); if (StringUtils.isEmpty(name)) { sendNSFailed( streamConn, StatusCodes.NS_FAILED, "The stream name may not be empty.", name, streamId); log.error("The stream name may not be empty."); return; } IStreamSecurityService security = (IStreamSecurityService) ScopeUtils.getScopeService(scope, IStreamSecurityService.class); if (security != null) { Set<IStreamPublishSecurity> handlers = security.getStreamPublishSecurity(); for (IStreamPublishSecurity handler : handlers) { if (!handler.isPublishAllowed(scope, name, mode)) { sendNSFailed( streamConn, StatusCodes.NS_PUBLISH_BADNAME, "You are not allowed to publish the stream.", name, streamId); log.error("You are not allowed to publish the stream {}", name); return; } } } IBroadcastScope bsScope = getBroadcastScope(scope, name); if (bsScope != null && !bsScope.getProviders().isEmpty()) { // another stream with that name is already published sendNSFailed(streamConn, StatusCodes.NS_PUBLISH_BADNAME, name, name, streamId); log.error("Bad name {}", name); return; } IClientStream stream = streamConn.getStreamById(streamId); if (stream != null && !(stream instanceof IClientBroadcastStream)) { log.error( "Stream not found or is not instance of IClientBroadcastStream, name: {}, streamId: {}", name, streamId); return; } boolean created = false; if (stream == null) { stream = streamConn.newBroadcastStream(streamId); created = true; } IClientBroadcastStream bs = (IClientBroadcastStream) stream; try { // set publish name bs.setPublishedName(name); // set stream parameters if they exist if (params != null) { bs.setParameters(params); } IContext context = conn.getScope().getContext(); IProviderService providerService = (IProviderService) context.getBean(IProviderService.BEAN_NAME); // TODO handle registration failure if (providerService.registerBroadcastStream(conn.getScope(), name, bs)) { bsScope = getBroadcastScope(conn.getScope(), name); bsScope.setClientBroadcastStream(bs); if (conn instanceof BaseConnection) { ((BaseConnection) conn).registerBasicScope(bsScope); } } log.debug("Mode: {}", mode); if (IClientStream.MODE_RECORD.equals(mode)) { bs.start(); bs.saveAs(name, false); } else if (IClientStream.MODE_APPEND.equals(mode)) { bs.start(); bs.saveAs(name, true); } else { bs.start(); } bs.startPublishing(); } catch (IOException e) { log.warn("Stream I/O exception", e); sendNSFailed( streamConn, StatusCodes.NS_RECORD_NOACCESS, "The file could not be created/written to.", name, streamId); bs.close(); if (created) { streamConn.deleteStreamById(streamId); } } catch (Exception e) { log.warn("Exception on publish", e); } } }
/** {@inheritDoc} */ public void play(String name, int start, int length, boolean flushPlaylist) { log.debug( "Play called - name: {} start: {} length: {} flush playlist: {}", new Object[] {name, start, length, flushPlaylist}); IConnection conn = Red5.getConnectionLocal(); if (conn instanceof IStreamCapableConnection) { IScope scope = conn.getScope(); IStreamCapableConnection streamConn = (IStreamCapableConnection) conn; int streamId = conn.getStreamId(); if (StringUtils.isEmpty(name)) { sendNSFailed( streamConn, StatusCodes.NS_FAILED, "The stream name may not be empty.", name, streamId); return; } IStreamSecurityService security = (IStreamSecurityService) ScopeUtils.getScopeService(scope, IStreamSecurityService.class); if (security != null) { Set<IStreamPlaybackSecurity> handlers = security.getStreamPlaybackSecurity(); for (IStreamPlaybackSecurity handler : handlers) { if (!handler.isPlaybackAllowed(scope, name, start, length, flushPlaylist)) { sendNSFailed( streamConn, StatusCodes.NS_FAILED, "You are not allowed to play the stream.", name, streamId); return; } } } boolean created = false; IClientStream stream = streamConn.getStreamById(streamId); if (stream == null) { if (streamId <= 0) { streamId = streamConn.reserveStreamId(); } stream = streamConn.newPlaylistSubscriberStream(streamId); stream.setBroadcastStreamPublishName(name); stream.start(); created = true; } if (stream != null && stream instanceof ISubscriberStream) { ISubscriberStream subscriberStream = (ISubscriberStream) stream; IPlayItem item = simplePlayback.get() ? SimplePlayItem.build(name, start, length) : DynamicPlayItem.build(name, start, length); if (subscriberStream instanceof IPlaylistSubscriberStream) { IPlaylistSubscriberStream playlistStream = (IPlaylistSubscriberStream) subscriberStream; if (flushPlaylist) { playlistStream.removeAllItems(); } playlistStream.addItem(item); } else if (subscriberStream instanceof ISingleItemSubscriberStream) { ISingleItemSubscriberStream singleStream = (ISingleItemSubscriberStream) subscriberStream; singleStream.setPlayItem(item); } else { // not supported by this stream service log.warn( "Stream instance type: {} is not supported", subscriberStream.getClass().getName()); return; } try { subscriberStream.play(); } catch (IOException err) { if (created) { stream.close(); streamConn.deleteStreamById(streamId); } sendNSFailed(streamConn, StatusCodes.NS_FAILED, err.getMessage(), name, streamId); } } } else { log.debug("Connection was not stream capable"); } }