red5源码分析---10
red5源码分析—服务器处理publish命令
和前几章的分析一样，服务器接收到客户端发来的publish命令后，最终会执行RTMPHandler的onCommand函数，再参考《red5源码分析—8》的分析，最终会调用StreamService的publish方法，代码如下
public void publish(String name, String mode) {
Map<String, String> params = null;
if (name != null && name.contains("?")) {
params = new HashMap<String, String>();
String tmp = name;
if (name.charAt(0) != '?') {
tmp = name.split("\\?")[1];
} else if (name.charAt(0) == '?') {
tmp = name.substring(1);
}
String[] kvs = tmp.split("&");
for (String kv : kvs) {
String[] split = kv.split("=");
params.put(split[0], split[1]);
}
name = name.substring(0, name.indexOf("?"));
}
IConnection conn = Red5.getConnectionLocal();
if (conn instanceof IStreamCapableConnection) {
IScope scope = conn.getScope();
IStreamCapableConnection streamConn = (IStreamCapableConnection) conn;
Number streamId = conn.getStreamId();
if (StringUtils.isEmpty(name)) {
return;
}
IStreamSecurityService security = (IStreamSecurityService) ScopeUtils.getScopeService(scope, IStreamSecurityService.class);
if (security != null) {
Set handlers = security.getStreamPublishSecurity();
for (IStreamPublishSecurity handler : handlers) {
if (!handler.isPublishAllowed(scope, name, mode)) {
return;
}
}
}
IBroadcastScope bsScope = getBroadcastScope(scope, name);
if (bsScope != null && !bsScope.getProviders().isEmpty()) {
return;
}
IClientStream stream = streamConn.getStreamById(streamId);
if (stream != null && !(stream instanceof IClientBroadcastStream)) {
return;
}
boolean created = false;
if (stream == null) {
stream = streamConn.newBroadcastStream(streamId);
created = true;
}
IClientBroadcastStream bs = (IClientBroadcastStream) stream;
try {
bs.setPublishedName(name);
if (params != null) {
bs.setParameters(params);
}
IContext context = conn.getScope().getContext();
IProviderService providerService = (IProviderService) context.getBean(IProviderService.BEAN_NAME);
if (providerService.registerBroadcastStream(conn.getScope(), name, bs)) {
bsScope = getBroadcastScope(conn.getScope(), name);
bsScope.setClientBroadcastStream(bs);
if (conn instanceof BaseConnection) {
((BaseConnection) conn).registerBasicScope(bsScope);
}
}
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) {
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) {
}
}
}
publish函数首先对传入的参数name进行处理，从name中提取出请求参数并保存在params中，将name去除参数部分，这个name就可以唯一表示一个publish流；publish函数接下来执行ScopeUtils的getScopeService方法构造StreamSecurityService用来对安全方面进行验证，这里不管它；然后通过getBroadcastScope检查对应的name下是否已经创建过BroadcastScope，一个BoradcastScope表示某个Scope下的某种类型的Scope，代码如下
public IBroadcastScope getBroadcastScope(IScope scope, String name) {
return scope.getBroadcastScope(name);
}
public IBroadcastScope getBroadcastScope(String name) {
return (IBroadcastScope) children.getBasicScope(ScopeType.BROADCAST, name);
}如果对应的name下已经创建过BroadcastScope并且已被占用，getBroadcastScope就直接返回。
回到publish中，再往下就根据streamId检查RTMPMinaConnection连接里对应的IClientStream是否也被占用，如果被占用也直接返回。这里假设BroadcastScope和IClientStream都没有创建或被占用，因此接下来通过newBroadcastStream创建stream，newBroadcastStream定义在RTMPConnection中，
public IClientBroadcastStream newBroadcastStream(Number streamId) {
if (isValidStreamId(streamId)) {
ClientBroadcastStream cbs = (ClientBroadcastStream) scope.getContext().getBean("clientBroadcastStream");
customizeStream(streamId, cbs);
if (!registerStream(cbs)) {
cbs = null;
}
return cbs;
}
return null;
}newBroadcastStream函数首先通过isValidStreamId检查streamId的合法性，以及是否在该Id下已经创建了流。如果合法，就通过Spring创建ClientBroadcastStream，然后通过customizeStream设置ClientBroadcastStream对应的连接、Scope、name以及streamId，
private void customizeStream(Number streamId, AbstractClientStream stream) {
Integer buffer = streamBuffers.get(streamId.doubleValue());
if (buffer != null) {
stream.setClientBufferDuration(buffer);
}
stream.setName(createStreamName());
stream.setConnection(this);
stream.setScope(this.getScope());
stream.setStreamId(streamId);
}newBroadcastStream接下来执行registerStream向RTMPMinaConnection注册刚刚创建的流ClientBroadcastStream，
private boolean registerStream(IClientStream stream) {
if (streams.putIfAbsent(stream.getStreamId().doubleValue(), stream) == null) {
usedStreams.incrementAndGet();
return true;
}
return false;
}回到publish中，再往下对刚刚创建的ClientBroadcastStream进行基本的设置。然后就通过Spring获得ProviderService，并调用其registerBroadcastStream注册刚刚创建的ClientBroadcastStream，代码如下
public boolean registerBroadcastStream(IScope scope, String name, IBroadcastStream bs) {
IBroadcastScope broadcastScope = scope.getBroadcastScope(name);
if (broadcastScope == null) {
broadcastScope = new BroadcastScope(scope, name);
if (scope.addChildScope(broadcastScope)) {
} else {
}
}
if (broadcastScope != null && bs instanceof IClientBroadcastStream) {
broadcastScope.setClientBroadcastStream((IClientBroadcastStream) bs);
}
return broadcastScope.subscribe(bs.getProvider(), null);
}registerBroadcastStream函数首先会创建一个BroadcastScope，其构造函数如下，
public BroadcastScope(IScope parent, String name) {
super(parent, ScopeType.BROADCAST, name, false);
pipe = new InMemoryPushPushPipe(this);
keepOnDisconnect = true;
}注意这里会创建一个管道InMemoryPushPushPipe，后面的章节会分析到这个管道。
registerBroadcastStream函数接下来会调用addChildScope将刚刚创建的BroadcastScope注册到其父Scope上，该函数之前的章节分析过了；接着会将对应的stream流设置进BroadcastScope里；最后通过subscribe注册自身成为Provider，BroadcastScope里的Provider表示一个流的提供者，getProvider返回的是ClientBroadcastStream自身，subscribe定义如下，
public boolean subscribe(IProvider provider, Map paramMap) {
return !removed && pipe.subscribe(provider, paramMap);
} pipe就是刚刚在BroadcastScope构造函数中创建的InMemoryPushPushPipe，其subscribe函数如下，
public boolean subscribe(IProvider provider, Map paramMap) {
boolean success = super.subscribe(provider, paramMap);
if (success) {
fireProviderConnectionEvent(provider, PipeConnectionEvent.PROVIDER_CONNECT_PUSH, paramMap);
}
return success;
} InMemoryPushPushPipe的父类为AbstractPipe，其subscribe如下，
public boolean subscribe(IProvider provider, Map paramMap) {
boolean success = providers.addIfAbsent(provider);
if (success && provider instanceof IPipeConnectionListener) {
listeners.addIfAbsent((IPipeConnectionListener) provider);
}
return success;
} AbstractPipe的subscribe函数就是向InMemoryPushPushPipe的providers注册Provider，即流的提供者，并且添加监听器，因为ClientBroadcastStream自身实现了IPipeConnectionListener接口。
回到InMemoryPushPushPipe的subscribe函数中，接下来通过fireProviderConnectionEvent触发监听回调函数，fireProviderConnectionEvent的代码如下，
protected void fireProviderConnectionEvent(IProvider provider, int type, Map paramMap) {
PipeConnectionEvent event = new PipeConnectionEvent(this);
event.setProvider(provider);
event.setType(type);
event.setParamMap(paramMap);
firePipeConnectionEvent(event);
} 这里构造了PipeConnectionEvent，即代表管道连接的事件，接着通过firePipeConnectionEvent触发监听器，
protected void firePipeConnectionEvent(PipeConnectionEvent event) {
for (IPipeConnectionListener element : listeners) {
try {
element.onPipeConnectionEvent(event);
} catch (Throwable t) {
}
}
if (taskExecutor == null) {
taskExecutor = Executors.newCachedThreadPool(new CustomizableThreadFactory("Pipe-"));
}
for (Runnable task : event.getTaskList()) {
try {
taskExecutor.execute(task);
} catch (Throwable t) {
}
}
event.getTaskList().clear();
}首先通过onPipeConnectionEvent触发监听器事件，接着启动线程处理各个task。因为前面的subscribe函数中注册了监听器，即ClientBroadcastStream自身，这里的onPipeConnectionEvent定义在ClientBroadcastStream中，
public void onPipeConnectionEvent(PipeConnectionEvent event) {
switch (event.getType()) {
case PipeConnectionEvent.PROVIDER_CONNECT_PUSH:
if (event.getProvider() == this && event.getSource() != connMsgOut && (event.getParamMap() == null || !event.getParamMap().containsKey("record"))) {
this.livePipe = (IPipe) event.getSource();
for (IConsumer consumer : this.livePipe.getConsumers()) {
subscriberStats.increment();
}
}
break;
case PipeConnectionEvent.PROVIDER_DISCONNECT:
...
break;
case PipeConnectionEvent.CONSUMER_CONNECT_PUSH:
...
break;
case PipeConnectionEvent.CONSUMER_DISCONNECT:
...
break;
default:
}
}因为前面设置的PipeConnectionEvent的事件类型为PROVIDER_CONNECT_PUSH，因此只看这一部分代码，onPipeConnectionEvent函数其实只是设置了成员变量livePipe，其实也是InMemoryPushPushPipe自身。
回到publish中，假设registerBroadcastStream注册成功，接下来通过getBroadcastScope获得前面创建的BroadcastScope并设置对应的ClientBroadcastStream；接着调用registerBasicScope设置刚刚创建的BroadcastScope，registerBasicScope定义在BaseConnection中，
public void registerBasicScope(IBroadcastScope basicScope) {
basicScopes.add(basicScope);
basicScope.addEventListener(this);
}再回到publish中，假设前面客户端的请求中参数mode是MODE_LIVE，因此调用ClientBroadcastStream的start函数和startPublishing函数，下面分别分析。
start函数
start定义在ClientBroadcastStream中，
public void start() {
checkVideoCodec = true;
checkAudioCodec = true;
firstPacketTime = -1;
latestTimeStamp = -1;
bytesReceived = 0;
IConsumerService consumerManager = (IConsumerService) getScope().getContext().getBean(IConsumerService.KEY);
connMsgOut = consumerManager.getConsumerOutput(this);
if (connMsgOut != null && connMsgOut.subscribe(this, null)) {
setCodecInfo(new StreamCodecInfo());
creationTime = System.currentTimeMillis();
closed = false;
} else {
}
}在进行一些成员变量的初始化后，start函数通过Spring获得ConsumerService，并调用其getConsumerOutput函数创建另一个管道并作相应的设置，
public IMessageOutput getConsumerOutput(IClientStream stream) {
IStreamCapableConnection streamConn = stream.getConnection();
if (streamConn != null && streamConn instanceof RTMPConnection) {
RTMPConnection conn = (RTMPConnection) streamConn;
OutputStream o = conn.createOutputStream(stream.getStreamId());
IPipe pipe = new InMemoryPushPushPipe();
pipe.subscribe(new ConnectionConsumer(conn, o.getVideo(), o.getAudio(), o.getData()), null);
return pipe;
}
return null;
}getConsumerOutput首先通过ClientBroadcastStream获得RTMPMinaConnection连接，并执行其createOutputStream创建输出流，该函数前面的章节已经分析过了，这里再看一次，
public OutputStream createOutputStream(Number streamId) {
int channelId = getChannelIdForStreamId(streamId);
final Channel data = getChannel(channelId++);
final Channel video = getChannel(channelId++);
final Channel audio = getChannel(channelId++);
return new OutputStream(video, audio, data);
}createOutputStream通过获得数据、音频、视频的Channel构造了一个OutputStream并返回。
回到getConsumerOutput函数中，接下来构造了一个ConnectionConsumer，然后创建了另一个管道InMemoryPushPushPipe并执行该管道的subscribe函数，
public boolean subscribe(IConsumer consumer, Map paramMap) {
if (consumer instanceof IPushableConsumer) {
boolean success = super.subscribe(consumer, paramMap);
if (success) {
fireConsumerConnectionEvent(consumer, PipeConnectionEvent.CONSUMER_CONNECT_PUSH, paramMap);
}
return success;
} else {
}
} 前面已经分析了一遍subscribe函数，但是这里传入的参数不是IProvider，而是IConsumer，继续看其父类的subscribe函数，
public boolean subscribe(IConsumer consumer, Map paramMap) {
boolean success = consumers.addIfAbsent(consumer);
if (success && consumer instanceof IPipeConnectionListener) {
listeners.addIfAbsent((IPipeConnectionListener) consumer);
}
return success;
} 该函数只是添加了Consumer以及监听器。
继续回到子类InMemoryPushPushPipe的subscribe函数中，假设执行成功，就调用fireConsumerConnectionEvent触发监听事件了，
protected void fireConsumerConnectionEvent(IConsumer consumer, int type, Map paramMap) {
PipeConnectionEvent event = new PipeConnectionEvent(this);
event.setConsumer(consumer);
event.setType(type);
event.setParamMap(paramMap);
firePipeConnectionEvent(event);
} 这里依然构造了PipeConnectionEvent事件，并调用firePipeConnectionEvent开始处理，
protected void firePipeConnectionEvent(PipeConnectionEvent event) {
for (IPipeConnectionListener element : listeners) {
try {
element.onPipeConnectionEvent(event);
} catch (Throwable t) {
}
}
if (taskExecutor == null) {
taskExecutor = Executors.newCachedThreadPool(new CustomizableThreadFactory("Pipe-"));
}
for (Runnable task : event.getTaskList()) {
try {
taskExecutor.execute(task);
} catch (Throwable t) {
}
}
event.getTaskList().clear();
}首先通过onPipeConnectionEvent触发监听器事件，接着启动线程处理各个task。这里的onPipeConnectionEvent定义在ClientBroadcastStream中，
public void onPipeConnectionEvent(PipeConnectionEvent event) {
switch (event.getType()) {
case PipeConnectionEvent.PROVIDER_CONNECT_PUSH:
...
break;
case PipeConnectionEvent.PROVIDER_DISCONNECT:
...
break;
case PipeConnectionEvent.CONSUMER_CONNECT_PUSH:
IPipe pipe = (IPipe) event.getSource();
if (this.livePipe == pipe) {
notifyChunkSize();
}
subscriberStats.increment();
break;
case PipeConnectionEvent.CONSUMER_DISCONNECT:
...
break;
default:
}
}和前面不同的是，这里触发的是PipeConnectionEvent.CONSUMER_CONNECT_PUSH事件，但其实什么也没做。
值得注意的subscribe函数会回调刚刚创建的ConnectionConsumer的onPipeConnectionEvent函数，但其实什么都没做，代码如下，
public void onPipeConnectionEvent(PipeConnectionEvent event) {
switch (event.getType()) {
case PipeConnectionEvent.PROVIDER_DISCONNECT:
closeChannels();
break;
default:
}
}回到ClientBroadcastStream的start函数中，返回的InMemoryPushPushPipe保存在connMsgOut中，接下来又执行了一遍subscribe，继续往InMemoryPushPushPipe注册Consumer，这里的回调函数就定义在ClientBroadcastStream中，刚刚也已经分析过了。假设注册成功，接下来就创建一个StreamCodecInfo并进行相应的设置，后面的章节会分析到。
startPublishing函数
startPublishing定义在ClientBroadcastStream中，代码如下，
public void startPublishing() {
sendStartNotifications(Red5.getConnectionLocal());
if (automaticRecording) {
try {
saveAs(publishedName, false);
} catch (Exception e) {
}
}
}首先通过sendStartNotifications发送流即将开始的通知，代码如下，
private void sendStartNotifications(IEventListener source) {
if (sendStartNotification) {
sendStartNotification = false;
if (source instanceof IConnection) {
IScope scope = ((IConnection) source).getScope();
if (scope.hasHandler()) {
final Object handler = scope.getHandler();
if (handler instanceof IStreamAwareScopeHandler) {
if (recordingListener != null && recordingListener.get().isRecording()) {
((IStreamAwareScopeHandler) handler).streamRecordStart(this);
} else {
try {
File file = getRecordFile(scope, publishedName);
if (file != null && file.exists()) {
if (!file.delete()) {
}
}
} catch (Exception e) {
}
((IStreamAwareScopeHandler) handler).streamPublishStart(this);
}
}
}
}
sendPublishStartNotify();
if (recordingListener != null && recordingListener.get().isRecording()) {
sendRecordStartNotify();
}
notifyBroadcastStart();
}
}sendStartNotification在ClientBroadcastStream创建时就默认为true，因为sendStartNotifications只执行一次，因此进入后首先将sendStartNotification设置为false。
传入的参数source实际上就是RTMPMinaConnection，通过getScope获得其对应的Scope后，再通过getHandler获得对应的handler，实际上就是CoreHandler，并没有实现IStreamAwareScopeHandler接口。
再往下通过sendPublishStartNotify向管道推送消息，
private void sendPublishStartNotify() {
Status publishStatus = new Status(StatusCodes.NS_PUBLISH_START);
publishStatus.setClientid(getStreamId());
publishStatus.setDetails(getPublishedName());
StatusMessage startMsg = new StatusMessage();
startMsg.setBody(publishStatus);
pushMessage(startMsg);
}这里主要创建了状态为StatusCodes.NS_PUBLISH_START的Status，包装为消息后，然后通过pushMessage发送该消息，
protected void pushMessage(StatusMessage msg) {
if (connMsgOut != null) {
try {
connMsgOut.pushMessage(msg);
} catch (IOException err) {
}
} else {
}
}connMsgOut就是前面在ClientBroadcastStream中创建的InMemoryPushPushPipe，来看它的pushMessage函数，
public void pushMessage(IMessage message) throws IOException {
for (IConsumer consumer : consumers) {
try {
IPushableConsumer pcon = (IPushableConsumer) consumer;
if (message instanceof RTMPMessage) {
RTMPMessage rtmpMessage = (RTMPMessage) message;
IRTMPEvent body = rtmpMessage.getBody();
int time = body.getTimestamp();
pcon.pushMessage(this, message);
body.setTimestamp(time);
} else {
pcon.pushMessage(this, message);
}
} catch (Throwable t) {
}
}
}刚函数获取该管道注册过的IConsumer，跟着前面的分析，这里传入的message并没有继承或实现RTMPMessage，因此直接调用每个IConsumer的pushMessage函数。
根据本章前面的分析结果，之前一共注册了两个IConsumer，一个是在ClientBroadcastStream的getConsumerOutput函数中创建的ConnectionConsumer，另一个也是在ClientBroadcastStream的start函数中注册的自身，因为ClientBroadcastStream实现的IPushableConsumer接口继承自IConsumer，下面分别来看它们的pushMessage函数，
ConnectionConsumer的pushMessage函数的代码如下，
public void pushMessage(IPipe pipe, IMessage message) {
if (message instanceof ResetMessage) {
} else if (message instanceof StatusMessage) {
StatusMessage statusMsg = (StatusMessage) message;
data.sendStatus(statusMsg.getBody());
} else if (message instanceof RTMPMessage) {
...
} else {
}
}因为传入的message就是StatusMessage，因此这里通过ConnectionConsumer的数据Channel(data)发送出去了，sendStatus定义在Channel中，代码如下，
public void sendStatus(Status status) {
if (connection != null) {
final boolean andReturn = !status.getCode().equals(StatusCodes.NS_DATA_START);
final Invoke event = new Invoke();
if (andReturn) {
final PendingCall call = new PendingCall(null, CALL_ON_STATUS, new Object[] { status });
if (status.getCode().equals(StatusCodes.NS_PLAY_START)) {
...
}
event.setCall(call);
} else {
...
}
write(event, connection.getStreamIdForChannelId(id));
}
}根据前面的分析，传入的statusCode是NS_PUBLISH_START，因此andReturn为true，sendStatus设置PendingCall后，就直接调用write将数据发送给客户端了。
ClientBroadcastStream的pushMessage函数为空。
回到sendStartNotifications函数中，接下来通过notifyBroadcastStart触发别的监听器，但其实什么也没做。
再回到startPublishing函数中，接下来调用saveAs继续处理，
public void saveAs(String name, boolean isAppend) throws IOException {
IStreamCapableConnection conn = getConnection();
if (recordingListener == null) {
IRecordingListener listener = new RecordingListener();
if (listener.init(conn, name, isAppend)) {
IStreamCodecInfo codecInfo = getCodecInfo();
if (codecInfo instanceof StreamCodecInfo) {
StreamCodecInfo info = (StreamCodecInfo) codecInfo;
IVideoStreamCodec videoCodec = info.getVideoCodec();
if (videoCodec != null) {
IoBuffer config = videoCodec.getDecoderConfiguration();
if (config != null) {
VideoData videoConf = new VideoData(config.asReadOnlyBuffer());
try { listener.getFileConsumer().setVideoDecoderConfiguration(videoConf);
} finally {
videoConf.release();
}
}
} else {
}
IAudioStreamCodec audioCodec = info.getAudioCodec();
if (audioCodec != null) {
IoBuffer config = audioCodec.getDecoderConfiguration();
if (config != null) {
AudioData audioConf = new AudioData(config.asReadOnlyBuffer());
try { listener.getFileConsumer().setAudioDecoderConfiguration(audioConf);
} finally {
audioConf.release();
}
}
} else {
}
}
recordingListener = new WeakReference(listener);
addStreamListener(listener);
listener.start();
} else {
}
} else {
}
} saveAs函数首先创建了一个RecordingListener，并调用其init函数进行初始化，init函数的代码如下，
public boolean init(IConnection conn, String name, boolean isAppend) {
return init(conn.getScope(), name, isAppend);
}
public boolean init(IScope scope, String name, boolean isAppend) {
File file = getRecordFile(scope, name);
if (file != null) {
if (!isAppend) {
if (file.exists()) {
if (!file.delete()) {
return false;
}
}
} else {
if (file.exists()) {
appending = true;
} else {
isAppend = false;
}
}
if (!file.exists()) {
String path = file.getAbsolutePath();
int slashPos = path.lastIndexOf(File.separator);
if (slashPos != -1) {
path = path.substring(0, slashPos);
}
File tmp = new File(path);
if (!tmp.isDirectory()) {
tmp.mkdirs();
}
try {
file.createNewFile();
} catch (IOException e) {
return false;
}
}
if (scope.getContext().hasBean("keyframe.cache")) {
IKeyFrameMetaCache keyFrameCache = (IKeyFrameMetaCache) scope.getContext().getBean("keyframe.cache");
keyFrameCache.removeKeyFrameMeta(file);
}
if (scope.getContext().hasBean("fileConsumer")) {
recordingConsumer = (FileConsumer) scope.getContext().getBean("fileConsumer");
recordingConsumer.setScope(scope);
recordingConsumer.setFile(file);
} else {
recordingConsumer = new FileConsumer(scope, file);
}
if (isAppend) {
recordingConsumer.setMode("append");
} else {
recordingConsumer.setMode("record");
}
setFileName(file.getName());
scheduler = (QuartzSchedulingService) scope.getParent().getContext().getBean(QuartzSchedulingService.BEAN_NAME);
recording.set(true);
} else {
}
return recording.get();
}init函数首先根据Scope和name通过getRecordFile函数获取文件，代码如下，
public static File getRecordFile(IScope scope, String name) {
IStreamFilenameGenerator generator = (IStreamFilenameGenerator) ScopeUtils.getScopeService(scope, IStreamFilenameGenerator.class, DefaultStreamFilenameGenerator.class);
String fileName = generator.generateFilename(scope, name, ".flv", GenerationType.RECORD);
File file = null;
if (generator.resolvesToAbsolutePath()) {
file = new File(fileName);
} else {
Resource resource = scope.getContext().getResource(fileName);
if (resource.exists()) {
try {
file = resource.getFile();
} catch (IOException ioe) {
}
} else {
String appScopeName = ScopeUtils.findApplication(scope).getName();
file = new File(String.format("%s/webapps/%s/%s", System.getProperty("red5.root"), appScopeName, fileName));
}
}
return file;
}getRecordFile函数首先通过ScopeUtils的getScopeService函数构造一个DefaultStreamFilenameGenerator，并通过其generateFilename函数生成文件名，
public String generateFilename(IScope scope, String name, GenerationType type) {
return generateFilename(scope, name, null, type);
}
public String generateFilename(IScope scope, String name, String extension, GenerationType type) {
String result = getStreamDirectory(scope) + name;
if (extension != null && !extension.equals("")) {
result += extension;
}
return result;
}getStreamDirectory获取Scope对应的路径名，因此最后的文件名为”Scope路径名+name+extension”。
回到getRecordFile函数中，resolvesToAbsolutePath函数默认返回false，因此直接看接下来的else部分，因为是第一次创建，因此getResource返回的Resource不存在，因此最后会创建一个File，用来存储流的数据。
回到RecordingListener的init函数中，传入的参数isAppend为false，因此这里会删除同名File，紧接下来就会通过createNewFile创建该File。
再往下，init函数会根据red5-common.xml配置文件创建CachingFileKeyFrameMetaCache，并
public void removeKeyFrameMeta(File file) {
rwLock.writeLock().lock();
try {
String canonicalPath = file.getCanonicalPath();
inMemoryMetaCache.remove(canonicalPath);
} catch (IOException e) {
} finally {
rwLock.writeLock().unlock();
}
super.removeKeyFrameMeta(file);
}
public void removeKeyFrameMeta(File file) {
String filename = String.format("%s.meta", file.getAbsolutePath());
File metadataFile = new File(filename);
if (metadataFile.exists()) {
if (metadataFile.delete()) {
} else {
metadataFile.deleteOnExit();
}
} else {
}
}这里其实就是删除流文件对应的信息文件。
回到init函数中，再往下创建了一个FileConsumer并设置其模式为record，最后返回true。
回到saveAs函数中，RecordingListener初始化完成后，首先通过getCodecInfo获得前面在ClientBroadcastStream的start函数中创建的StreamCodecInfo，但是接下来的getVideoCodec和getAudioCodec返回空，所以直接跳到最后看，首先通过addStreamListener将刚刚创建的RecordingListener函数设置进ClientBroadcastStream的listeners中，
public void addStreamListener(IStreamListener listener) {
listeners.add(listener);
}接下来就调用RecordingListener的start函数了，
public void start() {
eqj = new EventQueueJob();
eventQueueJobName = scheduler.addScheduledJob(3000, eqj);
}start函数很简单，就是启用一个线程执行EventQueueJob，用来处理接收到的事件。
下一章开始分析客户端如何发送流给服务器。