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<IStreamPublishSecurity> 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<String, Object> paramMap) {        return !removed && pipe.subscribe(provider, paramMap);    }

pipe就是刚刚在BroadcastScope构造函数中创建的InMemoryPushPushPipe，其subscribe函数如下，

    public boolean subscribe(IProvider provider, Map<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<IRecordingListener>(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，用来处理接收到的事件。

下一章开始分析客户端如何发送流给服务器。