While most developers are content to record video using the NetStream.publish(“streamName”, “record”) API, it is sometimes useful to take FLV snippets from the publishing stream instead. In my opinion, this is one of the greatest features of Flash Media Server (FMS) and Red5. Utilizing this strategy allows the application developer to precisely control when and how much of the video is recorded. While recording via the NetStream function has been available in Red5 since the beginning, recording video from the server-side application has not. In this post, I'll demonstrate Red5's ability to record an FLV with a very simple pair of publish and subscribe flash applications.

I'll jump right in by creating a simple ApplicationAdapter subclass. This step isn't really necessary, however I feel that it is good practice when creating Red5 applications. As your application grows in functionality, you'll have the most essential building block ready to go.

Application.java

public class Application extends ApplicationAdapter {

	...

	/**
	 * Delegate method used to accept/reject incoming connection requests.
	 *
	 * @param conn
	 * @param params
	 * @return true/false
	 */
	@Override
	public boolean roomConnect(IConnection conn, Object[] params) {
		log.debug("New connection attempt from " + conn.getRemoteAddress() + "...");
		// Insure that the listeners are properly attached.
		return super.roomConnect(conn, params);
	}

	/**
	 * Delegate method which logs connection/client/user disconnections.
	 *
	 * @param conn
	 */
	@Override
	public void roomDisconnect(IConnection conn) {
		log.debug("Connection closed by " + conn.getRemoteAddress() + "...");
		// Call the super class to insure that all listeners are properly
		// dismissed.
		super.roomDisconnect(conn);
	}
}

As you can see, there isn't much to it, just a couple of logging statements to track new connections to the application. Next, I'll define a simple service bean to handle the NetConnection calls to start and stop the stream recordings.

StreamManager.java

public class StreamManager {

	...

	/**
	 * Start recording the publishing stream for the specified
	 * IConnection.
	 *
	 * @param conn
	 */
	public void recordShow(IConnection conn) {
		log.debug("Recording show for: " + conn.getScope().getContextPath());
		String streamName = String.valueOf(System.currentTimeMillis());
		// Get a reference to the current broadcast stream.
		ClientBroadcastStream stream = (ClientBroadcastStream) app.getBroadcastStream(
				conn.getScope(), "hostStream");
		try {
			// Save the stream to disk.
			stream.saveAs(streamName, false);
		} catch (Exception e) {
			log.error("Error while saving stream: " + streamName, e);
		}
	}

	/**
	 * Stops recording the publishing stream for the specified
	 * IConnection.
	 *
	 * @param conn
	 */
	public void stopRecordingShow(IConnection conn) {
		log.debug("Stop recording show for: " + conn.getScope().getContextPath());
		// Get a reference to the current broadcast stream.
		ClientBroadcastStream stream = (ClientBroadcastStream) app.getBroadcastStream(
				conn.getScope(), "hostStream");
		// Stop recording.
		stream.stopRecording();
	}

	...
}

This is where the meat of the application lies. The broadcast client starts recording the stream by calling streamManager.recordShow() and stops it by calling streamManager.stopRecordingShow(). In the example broadcast application, I've added a button to the Stage and created a simple onClick function to invoke the server-side methods.

BroadcastController.as

        /**
	 * Handle the record button click events.
	 */
	private function onClick(ev:Object):Void {
		// Record the stream by triggering a server event.
		if (ev.target.label == "Record") {
			// Tell the remote server to start recording.
			conn.call("streamManager.recordShow", null);
			// Re-label the button.
			button.label = "Stop";
		// Stop recording the stream.
		} else if (ev.target.label == "Stop") {
			// Tell the remote server to stop recording.
			conn.call("streamManager.stopRecordingShow", null);
			// Re-label the button.
			button.label = "Record";
		}
	}

Take note, the name of the recorded stream differs from that of the publishing stream. I am using a simple timestamp as a unique name for each new FLV. It is even possible to reuse an existing FLV and append new video data to it. Simply change the second argument of the stream.saveAs() method call to true while reusing the same stream name. Check the streams directory of the recorder application for the output files. Reviewing the FLVs is as easy as opening them up with an FLV player[1].

While this is an interesting bit of functionality, the possibilities are much greater. Consider, for example, a security application that needs to record video when the camera detects movement and also needs to have a unique file for each incident. With some minor tweaks to this example, you've got exactly that. In addition, it would be quite easy to extend this application to extract a JPEG preview snapshot from each FLV using FFMPEG[2].

The example source code for this post can be downloaded here.

1. http://www.wimpyplayer.com Wimpy Desktop FLV Player is a free cross platform (Mac and PC) standalone Flash Video FLV player for you, which will allow you to watch your FLV and SWF videos from your desktop. Check it out.

2. http://www.ffmpeg.org/ FFmpeg is a complete solution to record, convert and stream audio and video. It includes libavcodec, the leading audio/video codec library. FFmpeg is developed under Linux, but it can compiled under most operating systems, including Windows.