org.red5.server.api.stream.IBroadcastStream Java Examples

/**
 * Creates and starts a facade and adds an audio mux for the given scope.
 * 
 * @param scope
 * @param stream
 * @param useRTMPReader
 */
public void start(IScope scope, IBroadcastStream stream, boolean useRTMPReader) {
	log.debug("start - scope: {} stream: {} rtmp reader: {}", scope.getName(), stream.getPublishedName(), useRTMPReader);
	String streamName = stream.getPublishedName();
	start(streamName, useRTMPReader);
	// add the mux associated with the given scope
	AudioMux mux = muxService.getAudioMux(scope.getName());
	if (mux != null) {
		// get the facade for this stream
		segmentMap.get(streamName).setAudioMux(mux);
		// add the streams audio track to the muxer
		mux.addTrack(2, streamName); // TODO create a better way to know what our output channels are (defaulting to 2 / stereo)
	} else {
		log.warn("Audio mux service was not found");
	}
}
 

/** {@inheritDoc} */
public void packetReceived(IBroadcastStream stream, IStreamPacket packet) {
    if (recording.get()) {
        // store everything we would need to perform a write of the stream data
        CachedEvent event = new CachedEvent();
        event.setData(packet.getData().duplicate());
        event.setDataType(packet.getDataType());
        event.setReceivedTime(System.currentTimeMillis());
        event.setTimestamp(packet.getTimestamp());
        // queue the event
        if (!queue.add(event)) {
            log.debug("Event packet not added to recording queue");
        }
    } else {
        log.info("A packet was received by recording listener, but it's not recording anymore. {}", stream.getPublishedName());
    }
}
 

/** {@inheritDoc} */
public void publish(Boolean dontStop) {
    // null is as good as false according to Boolean.valueOf() so if null, interpret as false
    if (dontStop == null || !dontStop) {
        IConnection conn = Red5.getConnectionLocal();
        if (conn instanceof IStreamCapableConnection) {
            IStreamCapableConnection streamConn = (IStreamCapableConnection) conn;
            Number streamId = conn.getStreamId();
            IClientStream stream = streamConn.getStreamById(streamId);
            if (stream instanceof IBroadcastStream) {
                IBroadcastStream bs = (IBroadcastStream) stream;
                if (bs.getPublishedName() != null) {
                    IBroadcastScope bsScope = getBroadcastScope(conn.getScope(), bs.getPublishedName());
                    if (bsScope != null) {
                        bsScope.unsubscribe(bs.getProvider());
                        if (conn instanceof BaseConnection) {
                            ((BaseConnection) conn).unregisterBasicScope(bsScope);
                        }
                    }
                    bs.close();
                    streamConn.deleteStreamById(streamId);
                }
            }
        }
    }
}
 

@Override
public void packetReceived(IBroadcastStream stream, IStreamPacket packet) {

	RTMPMessage m = RTMPMessage.build((IRTMPEvent) packet, packet.getTimestamp());

	try {

		limiter--;
		if (limiter > 1) {
			streamer.pushMessage(null, m);
		} else {
			if (streamer != null) {
				stream.removeStreamListener(this);
				streamer.stop();
				streamer = null;
			}
		}

	} catch (IOException e) {

		e.printStackTrace();
	}

}
 

public void packetReceived(IBroadcastStream arg0, IStreamPacket packet) {

		if (done) {
			arg0.removeStreamListener(this);
			return;
		}

		messages = Red5.getConnectionLocal().getWrittenMessages() + Red5.getConnectionLocal().getReadMessages();

		bytesUp = Red5.getConnectionLocal().getReadBytes();

		bytesDown = Red5.getConnectionLocal().getWrittenBytes();

		if (packet instanceof Notify) {

			endpoint().invoke("onBWChunk", new Object[] { chunk });
			chunks++;
			//  Input reader = new Input(((Notify)packet).getData()); 
			//  reader.readDataType();//string
			//  String  method=reader.readString(null);
			//  reader.readDataType();//object
			//  Map invokeData=  (Map) reader.readMap(new Deserializer(), null);            
			//  System.out.println(method+""+invokeData.get("data").toString());	
		}
	}
 

@Override
public void streamPublishStart(final IBroadcastStream stream) {
	final String streamName = stream.getPublishedName();
	log.debug("streamPublishStart - stream name: {}", streamName);
	IConnection conn = Red5.getConnectionLocal();
	// save the record / stream name
	conn.setAttribute("streamName", streamName);
	super.streamPublishStart(stream);
	if (stream instanceof ClientBroadcastStream) {					
		Thread creator = new Thread(new Runnable() {
			public void run() {
				while (scope.getBroadcastScope(streamName) == null) {
					log.debug("Stream: {} is not available yet...", streamName);
					try {
						Thread.sleep(500L);
					} catch (InterruptedException e) {
					}
				}
				// get the segmenter
				SegmenterService segmenter = (SegmenterService) applicationContext.getBean("segmenter.service");
				// check that the stream is not already being segmented
				if (!segmenter.isAvailable(streamName)) {
					// start segmenting utilizing included RTMP reader
					segmenter.start(scope, stream, true);
				}					
			}
		});
		creator.setDaemon(true);
		creator.start();
	}		
}
 

/** {@inheritDoc} */
public IBroadcastStream getBroadcastStream(IScope scope, String name) {
    IStreamService service = (IStreamService) ScopeUtils.getScopeService(scope, IStreamService.class, StreamService.class);
    if (service instanceof StreamService) {
        IBroadcastScope bs = ((StreamService) service).getBroadcastScope(scope, name);
        if (bs != null) {
            return bs.getClientBroadcastStream();
        }
    }
    return null;
}
 

@Override
public void streamRecordStart(IBroadcastStream stream) {
	log.debug("streamRecordStart - stream name: {}", stream.getPublishedName());
	// save the record / stream name
	Red5.getConnectionLocal().setAttribute("streamName", stream.getPublishedName());
	super.streamRecordStart(stream);
}
 

@Override
public void streamBroadcastClose(IBroadcastStream stream) {
	log.debug("Broadcast close called. Stream name: {}", stream.getName());
	super.streamBroadcastClose(stream);
	// TODO: call the process to move the flv to S3 because its not possible to stream the bytes directly to S3 during flv write
	if (persistToS3) {
   		// move the completed flv to S3
   		S3FilenameGenerator.upload("Session-" + System.currentTimeMillis(), stream.getPublishedName());
	}
}
 

public void streamPublishStart(IBroadcastStream stream) {
    // log w3c connect event
    IConnection connection = Red5.getConnectionLocal();
    log.info("W3C x-category:stream x-event:publish c-ip:{} x-sname:{} x-name:{}", new Object[] { connection != null ? connection.getRemoteAddress() : "0.0.0.0", stream.getName(), stream.getPublishedName() });
}
 

@Override
public void streamBroadcastClose(IBroadcastStream stream) {
	log.debug("streamBroadcastClose - stream name: {}", stream.getPublishedName());
	super.streamBroadcastClose(stream);
}
 

public void streamRecordStop(IBroadcastStream stream) {
    // log w3c connect event
    IConnection connection = Red5.getConnectionLocal();
    log.info("W3C x-category:stream x-event:record-stop c-ip:{} x-sname:{} x-file-name:{}", new Object[] { connection != null ? connection.getRemoteAddress() : "0.0.0.0", stream.getName(), stream.getSaveFilename() });
}
 

public void streamRecordStart(IBroadcastStream stream) {
    // log w3c connect event
    IConnection connection = Red5.getConnectionLocal();
    log.info("W3C x-category:stream x-event:record-start c-ip:{} x-sname:{} x-file-name:{}", new Object[] { connection != null ? connection.getRemoteAddress() : "0.0.0.0", stream.getName(), stream.getSaveFilename() });
}
 

/** {@inheritDoc} */
public void packetReceived(IBroadcastStream stream, IStreamPacket packet);
 

public void streamBroadcastStart(IBroadcastStream stream) {
}
 

/**
 * Notification that a broadcasting stream is closing.
 * 
 * @param stream
 *            stream
 */
public void streamBroadcastClose(IBroadcastStream stream) {
    // log w3c connect event
    IConnection conn = Red5.getConnectionLocal();
    // converted to seconds
    long now = System.currentTimeMillis();
    long startTime = stream.getStartTime() > 0 ? stream.getStartTime() : now;
    long publishDuration = Math.max((now - startTime) / 1000, 0L);
    if (conn != null) {
        log.info("W3C x-category:stream x-event:unpublish c-ip:{} cs-bytes:{} sc-bytes:{} x-sname:{} x-file-length:{} x-name:{}", new Object[] { conn.getRemoteAddress(), conn.getReadBytes(), conn.getWrittenBytes(), stream.getName(), publishDuration, stream.getPublishedName() });
    } else {
        log.info("W3C x-category:stream x-event:unpublish x-sname:{} x-file-length:{} x-name:{}", new Object[] { stream.getName(), publishDuration, stream.getPublishedName() });
    }
    String recordingName = stream.getSaveFilename();
    // if its not null then we did a recording
    if (recordingName != null) {
        if (conn != null) {
            // use cs-bytes for file size for now
            log.info("W3C x-category:stream x-event:recordstop c-ip:{} cs-bytes:{} sc-bytes:{} x-sname:{} x-file-name:{} x-file-length:{} x-file-size:{}", new Object[] { conn.getRemoteAddress(), conn.getReadBytes(), conn.getWrittenBytes(), stream.getName(), recordingName, publishDuration, conn.getReadBytes() });
        } else {
            log.info("W3C x-category:stream x-event:recordstop x-sname:{} x-file-name:{} x-file-length:{}", new Object[] { stream.getName(), recordingName, publishDuration });
        }
        // if the stream length is 0 bytes then delete it, this is a fix for SN-20
        // get the web root
        String webappsPath = System.getProperty("red5.webapp.root");
        // add context name
        File file = new File(webappsPath, getName() + '/' + recordingName);
        if (file != null) {
            log.debug("File path: {}", file.getAbsolutePath());
            if (file.exists()) {
                // if publish duration or length are zero
                if (publishDuration == 0 || file.length() == 0) {
                    if (file.delete()) {
                        log.info("File {} was deleted", file.getName());
                    } else {
                        log.info("File {} was not deleted, it will be deleted on exit", file.getName());
                        file.deleteOnExit();
                    }
                }
            }
            file = null;
        }
    }
}
 

/**
 * Get a broadcast stream by name
 * 
 * @param scope
 *            the scope to return the stream from
 * @param name
 *            the name of the broadcast
 * @return broadcast stream object
 */
public IBroadcastStream getBroadcastStream(IScope scope, String name);
 

/**
 * Unregister a broadcast stream of a specific name from a scope.
 * 
 * @param scope
 *            Scope
 * @param name
 *            Stream name
 * @param stream
 *            Broadcast stream
 * @return true if unregister successfully.
 */
boolean unregisterBroadcastStream(IScope scope, String name, IBroadcastStream stream);
 

/**
 * Register a broadcast stream to a scope.
 * 
 * @param scope
 *            Scope
 * @param name
 *            Name of stream
 * @param stream
 *            Broadcast stream to register
 * @return true if register successfully.
 */
boolean registerBroadcastStream(IScope scope, String name, IBroadcastStream stream);