red5源码分析---13

red5源码分析—play命令分析

本章开始分析play命令，先来看客户端的代码，定义在BaseRTMPClientHandler中，

    public void play(Number streamId, String name, int start, int length) {        if (conn != null) {            int channel = getChannelForStreamId(streamId);            ping(Ping.CLIENT_BUFFER, streamId, 2000);            PendingCall receiveAudioCall = new PendingCall("receiveAudio");            conn.invoke(receiveAudioCall, channel);            PendingCall receiveVideoCall = new PendingCall("receiveVideo");            conn.invoke(receiveVideoCall, channel);            Object[] params = new Object[3];            params[0] = name;            params[1] = (start >= 1000 || start <= -1000) ? start : start * 1000;            params[2] = (length >= 1000 || length <= -1000) ? length : length * 1000;            PendingCall pendingCall = new PendingCall("play", params);            conn.invoke(pendingCall, channel);        } else {        }    }

BaseRTMPClientHandler的play一共向服务器发送了三条命令，receiveAudio、receiveVideo以及play，其中play命令包含了三个参数，分别是流的名称name，起始位置start，以及流的长度length。下面就开始分析服务器如何处理这三条命令。

play命令

根据前面几章的分析，play命令到达服务器后，最后会调用StreamService的play函数，代码如下，

    public void play(String name, int start, int length, boolean flushPlaylist) {        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<IStreamPlaybackSecurity> handlers = security.getStreamPlaybackSecurity();                for (IStreamPlaybackSecurity handler : handlers) {                    if (!handler.isPlaybackAllowed(scope, name, start, length, flushPlaylist)) {                        return;                    }                }            }            boolean created = false;            IClientStream stream = streamConn.getStreamById(streamId);            if (stream == null) {                try {                    if (streamId.doubleValue() <= 0.0d) {                        streamId = streamConn.reserveStreamId();                    }                    stream = streamConn.newPlaylistSubscriberStream(streamId);                    if (stream != null) {                        stream.setBroadcastStreamPublishName(name);                        stream.start();                        created = true;                    } else {                    }                } catch (Exception e) {                }            }            if (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 {                    return;                }                try {                    subscriberStream.play();                } catch (IOException err) {                }            }        } else {        }    }

关于安全方面的源码本章并不涉及，跳过play函数前面不重要的一些代码，假设从RTMPMinaConnection中取得的stream为null，下面就开始构造一个Stream了。
首先通过reserveStreamId函数随机分配一个streamId，该函数之前的章节分析过了。获得streamId之后，执行newPlaylistSubscriberStream函数创建一个PlaylistSubscriberStream，该函数定义在RTMPConnection中，

    public IPlaylistSubscriberStream newPlaylistSubscriberStream(Number streamId) {        if (isValidStreamId(streamId)) {            PlaylistSubscriberStream pss = (PlaylistSubscriberStream) scope.getContext().getBean("playlistSubscriberStream");            customizeStream(streamId, pss);            if (!registerStream(pss)) {                pss = null;            }            return pss;        }        return null;    }

newPlaylistSubscriberStream函数首先检查streamId的合法性，然后创建一个PlaylistSubscriberStream，接着调用customizeStream设置PlaylistSubscriberStream的基本信息，

    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);    }

注意这里PlaylistSubscriberStream的name是随机创建的。
回到RTMPConnection的newPlaylistSubscriberStream函数中，最后通过registerStream注册刚刚创建的PlaylistSubscriberStream，代码如下

    private boolean registerStream(IClientStream stream) {        if (streams.putIfAbsent(stream.getStreamId().doubleValue(), stream) == null) {            usedStreams.incrementAndGet();            return true;        }        return false;    }

回到play函数中，创建完PlaylistSubscriberStream后，执行setBroadcastStreamPublishName设置需要播放的流的名称，再往下就调用PlaylistSubscriberStream的start函数，代码如下，

    public void start() {        if (engine == null) {            IScope scope = getScope();            if (scope != null) {                IContext ctx = scope.getContext();                if (ctx.hasBean(ISchedulingService.BEAN_NAME)) {                    schedulingService = (ISchedulingService) ctx.getBean(ISchedulingService.BEAN_NAME);                } else {                    schedulingService = (ISchedulingService) scope.getParent().getContext().getBean(ISchedulingService.BEAN_NAME);                }                IConsumerService consumerService = null;                if (ctx.hasBean(IConsumerService.KEY)) {                    consumerService = (IConsumerService) ctx.getBean(IConsumerService.KEY);                } else {                    consumerService = (IConsumerService) scope.getParent().getContext().getBean(IConsumerService.KEY);                }                IProviderService providerService = null;                if (ctx.hasBean(IProviderService.BEAN_NAME)) {                    providerService = (IProviderService) ctx.getBean(IProviderService.BEAN_NAME);                } else {                    providerService = (IProviderService) scope.getParent().getContext().getBean(IProviderService.BEAN_NAME);                }                engine = new PlayEngine.Builder(this, schedulingService, consumerService, providerService).build();            } else {            }        }        engine.setBufferCheckInterval(bufferCheckInterval);        engine.setUnderrunTrigger(underrunTrigger);        engine.start();        onChange(StreamState.STARTED);    }

PlaylistSubscriberStream的start函数创建了QuartzSchedulingService、ConsumerService和ProviderService，这三个Service定义在Spring的配置文件red5-common.xml中，如下所示

    <bean id="providerService" class="org.red5.server.stream.ProviderService"/>    <bean id="consumerService" class="org.red5.server.stream.ConsumerService"/>    <bean id="schedulingService" class="org.red5.server.scheduling.QuartzSchedulingService">        <property name="configFile" value="${red5.root}/conf/quartz.properties"/>       </bean>

接下来，根据刚刚创建的三个Service创建一个PlayEngine，对PlayEngine进行相应的设置后，就调用PlayEngine的start函数，代码如下，

    public void start() {        switch (subscriberStream.getState()) {            case UNINIT:                subscriberStream.setState(StreamState.STOPPED);                if (msgOut == null) {                    msgOut = consumerService.getConsumerOutput(subscriberStream);                    msgOut.subscribe(this, null);                }                break;            default:        }    }

这里的subscriberStream成员变量就是PlaylistSubscriberStream，初始化时其成员变量state为UNINIT，
start函数首先设置PlaylistSubscriberStream的state为STOPPED，然后调用ConsumerService的getConsumerOutput获得一个InMemoryPushPushPipe，然后调用其subscribe注册PlaylistSubscriberStream自身。getConsumerOutput和subscribe函数在《red5源码分析—10》中详细分析过了，这里就不往下看了。

回到play函数中，接下来创建了一个SimplePlayItem，并且调用addItem添加到PlaylistSubscriberStream中，最后调用PlaylistSubscriberStream的play函数，

    public void play() throws IOException {        int count = items.size();        if (count == 0) {            return;        }        if (currentItemIndex == -1) {            moveToNext();        }        while (count-- > 0) {            IPlayItem item = null;            read.lock();            try {                item = items.get(currentItemIndex);                engine.play(item);                break;            } catch (StreamNotFoundException e) {                moveToNext();                if (currentItemIndex == -1) {                    break;                }                item = items.get(currentItemIndex);            } catch (IllegalStateException e) {                break;            } finally {                read.unlock();            }        }    }

PlaylistSubscriberStream的play函数获取刚刚创建的SimplePlayItem，并调用PlayEngine的play函数，

    public void play(IPlayItem item) throws StreamNotFoundException, IllegalStateException, IOException {        play(item, true);    }    public void play(IPlayItem item, boolean withReset) throws StreamNotFoundException, IllegalStateException, IOException {        switch (subscriberStream.getState()) {            case STOPPED:                if (msgIn != null) {                    msgIn.unsubscribe(this);                    msgIn = null;                }                break;            default:                throw new IllegalStateException("Cannot play from non-stopped state");        }        int type = (int) (item.getStart() / 1000);        IScope thisScope = subscriberStream.getScope();        final String itemName = item.getName();        IProviderService.INPUT_TYPE sourceType = providerService.lookupProviderInput(thisScope, itemName, type);        boolean isPublishedStream = sourceType == IProviderService.INPUT_TYPE.LIVE;        boolean isPublishedStreamWait = sourceType == IProviderService.INPUT_TYPE.LIVE_WAIT;        boolean isFileStream = sourceType == IProviderService.INPUT_TYPE.VOD;        boolean sendNotifications = true;        switch (type) {            case -2:                if (isPublishedStream) {                    playDecision = 0;                } else if (isFileStream) {                    playDecision = 1;                } else if (isPublishedStreamWait) {                    playDecision = 2;                }                break;            case -1:                if (isPublishedStream) {                    playDecision = 0;                } else {                    playDecision = 2;                }                break;            default:                if (isFileStream) {                    playDecision = 1;                }                break;        }        IMessage msg = null;        currentItem = item;        long itemLength = item.getLength();        switch (playDecision) {            case 0:                msgIn = providerService.getLiveProviderInput(thisScope, itemName, false);                if (msgIn == null) {                } else {                    videoFrameDropper.reset(IFrameDropper.SEND_KEYFRAMES_CHECK);                    if (msgIn instanceof IBroadcastScope) {                        IBroadcastStream stream = (IBroadcastStream) ((IBroadcastScope) msgIn).getClientBroadcastStream();                        if (stream != null && stream.getCodecInfo() != null) {                            IVideoStreamCodec videoCodec = stream.getCodecInfo().getVideoCodec();                            if (videoCodec != null) {                                if (withReset) {                                    sendReset();                                    sendResetStatus(item);                                    sendStartStatus(item);                                }                                sendNotifications = false;                                if (videoCodec.getNumInterframes() > 0 || videoCodec.getKeyframe() != null) {                                    bufferedInterframeIdx = 0;                                    videoFrameDropper.reset(IFrameDropper.SEND_ALL);                                }                            }                        }                    }                    if (msgIn != null) {                        msgIn.subscribe(this, null);                        playLive();                    } else {                    }                }                break;            case 2:                ...                break;            case 1:                ...                break;            default:        }        if (sendNotifications) {            if (withReset) {                sendReset();                sendResetStatus(item);            }            sendStartStatus(item);            if (!withReset) {                sendSwitchStatus();            }            if (item instanceof DynamicPlayItem) {                sendTransitionStatus();            }        }        if (msg != null) {            sendMessage((RTMPMessage) msg);        }        subscriberStream.onChange(StreamState.PLAYING, currentItem, !pullMode);        if (withReset) {            long currentTime = System.currentTimeMillis();            playbackStart = currentTime - streamOffset;            nextCheckBufferUnderrun = currentTime + bufferCheckInterval;            if (currentItem.getLength() != 0) {                ensurePullAndPushRunning();            }        }    }

playEngine函数首先对msgIn进行初始化，接着调用ProviderService的lookupProviderInput方法获取输入流，代码如下，

    public INPUT_TYPE lookupProviderInput(IScope scope, String name, int type) {        INPUT_TYPE result = INPUT_TYPE.NOT_FOUND;        if (scope.getBasicScope(ScopeType.BROADCAST, name) != null) {            result = INPUT_TYPE.LIVE;        } else {            result = INPUT_TYPE.VOD;            File file = getStreamFile(scope, name);            if (file == null) {                if (type == -2) {                    result = INPUT_TYPE.LIVE_WAIT;                }            }        }        return result;    }

参考《red5源码分析—10》，这里假设会获取到之前注册过的BroadcastScope，因此返回LIVE。

回到PlayEngine的play函数中，假设经过处理后的playDecision为0，下面来分析case为0的部分代码。首先会继续调用ProviderService的getLiveProviderInput方法获取一个BroadcastScope，

    public IMessageInput getLiveProviderInput(IScope scope, String name, boolean needCreate) {        IBroadcastScope broadcastScope = scope.getBroadcastScope(name);        if (broadcastScope == null && needCreate) {            synchronized (scope) {                broadcastScope = scope.getBroadcastScope(name);                if (broadcastScope == null) {                    broadcastScope = new BroadcastScope(scope, name);                    scope.addChildScope(broadcastScope);                }            }        }        return broadcastScope;    }

值得注意的是如果原先没有注册过BroadcastScope，getLiveProviderInput方法会根据name创建一个。

回到play函数中，根据返回的BroadcastScope获取相应的参数之后，就通过sendReset、sendResetStatus和sendStartStatus向客户端发送消息，通知流即将开始了。三个方法最后都是通过doPushMessage发送消息，代码如下

    private void doPushMessage(AbstractMessage message) {        if (msgOut != null) {            try {                msgOut.pushMessage(message);                if (message instanceof RTMPMessage) {                    IRTMPEvent body = ((RTMPMessage) message).getBody();                    lastMessageTs = body.getTimestamp();                    IoBuffer streamData = null;                    if (body instanceof IStreamData && (streamData = ((IStreamData<?>) body).getData()) != null) {                        bytesSent.addAndGet(streamData.limit());                    }                }            } catch (IOException err) {            }        } else {        }    }

doPushMessage函数中msgOut就是InMemoryPushPushPipe，其pushMessage函数在《red5源码分析—10》中已经详细分析过了。

回到PlayEngine的play函数中，接下来调用BroadcastScope的subscribe函数注册自身，这也是play命令最重要的一件事情，因为将subscripe注册进BroadcastScope中之后，当有Provider(即流的源)向red5服务器发送数据时，才能根据这些注册信息将数据推送给客户端。
play函数接着调用playLive函数，代码如下，

    private final void playLive() throws IOException {        subscriberStream.setState(StreamState.PLAYING);        streamOffset = 0;        streamStartTS.set(-1);        if (msgIn != null && msgOut != null) {            IBroadcastStream stream = (IBroadcastStream) ((IBroadcastScope) msgIn).getClientBroadcastStream();            if (stream != null) {                Notify metaData = stream.getMetaData();                if (metaData != null) {                    RTMPMessage metaMsg = RTMPMessage.build(metaData, 0);                    try {                        msgOut.pushMessage(metaMsg);                    } catch (IOException e) {                    }                } else {                }                IStreamCodecInfo codecInfo = stream.getCodecInfo();                if (codecInfo instanceof StreamCodecInfo) {                    StreamCodecInfo info = (StreamCodecInfo) codecInfo;                    IVideoStreamCodec videoCodec = info.getVideoCodec();                    if (videoCodec != null) {                        IoBuffer config = videoCodec.getDecoderConfiguration();                        if (config != null) {                            VideoData conf = new VideoData(config.asReadOnlyBuffer());                            RTMPMessage confMsg = RTMPMessage.build(conf);                            try {                                msgOut.pushMessage(confMsg);                            } finally {                                conf.release();                            }                        }                        IoBuffer keyFrame = videoCodec.getKeyframe();                        if (keyFrame != null) {                            VideoData video = new VideoData(keyFrame.asReadOnlyBuffer());                            RTMPMessage videoMsg = RTMPMessage.build(video);                            try {                                msgOut.pushMessage(videoMsg);                            } finally {                                video.release();                            }                        }                    } else {                    }                    IAudioStreamCodec audioCodec = info.getAudioCodec();                    if (audioCodec != null) {                        IoBuffer config = audioCodec.getDecoderConfiguration();                        if (config != null) {                            AudioData conf = new AudioData(config.asReadOnlyBuffer());                            RTMPMessage confMsg = RTMPMessage.build(conf);                            try {                                msgOut.pushMessage(confMsg);                            } finally {                                conf.release();                            }                        }                    } else {                    }                }            }        } else {        }    }

playLive函数主要向客户端发送metadata、解码器配置等等，这里就不详细分析了。
PlayEngine的play函数剩下的代码和主线无关，这里就不往下分析了。

纵观red5服务器对整个play命令的处理，其实最重要的就是将客户端注册进对应管道的Consumer中。回顾《red5源码分析—12》中ClientBroadcastStream的dispatchEvent函数，其中会调用livePipe的pushMessage函数，这里的livePipe就是BroadcastScope中创建的InMemoryPushPushPipe，其pushMessage函数会遍历InMemoryPushPushPipe中所有注册的Consumer，并调用其pushMessage函数，因此，下面来看PlayEngine的pushMessage函数，

    public void pushMessage(IPipe pipe, IMessage message) throws IOException {        if (message instanceof RTMPMessage) {            RTMPMessage rtmpMessage = (RTMPMessage) message;            IRTMPEvent body = rtmpMessage.getBody();            if (body instanceof IStreamData) {                if (subscriberStream.getState() == StreamState.PAUSED) {                    videoFrameDropper.dropPacket(rtmpMessage);                    return;                }                if (body instanceof VideoData) {                    if (msgIn instanceof IBroadcastScope) {                        IBroadcastStream stream = (IBroadcastStream) ((IBroadcastScope) msgIn).getClientBroadcastStream();                        if (stream != null && stream.getCodecInfo() != null) {                            IVideoStreamCodec videoCodec = stream.getCodecInfo().getVideoCodec();                            if (videoCodec != null && videoCodec.canDropFrames()) {                                if (!receiveVideo) {                                    videoFrameDropper.dropPacket(rtmpMessage);                                    return;                                }                                long pendingVideos = pendingVideoMessages();                                if (!videoFrameDropper.canSendPacket(rtmpMessage, pendingVideos)) {                                    return;                                }                                if (pendingVideos > 1) {                                    numSequentialPendingVideoFrames++;                                } else {                                    numSequentialPendingVideoFrames = 0;                                }                                if (pendingVideos > maxPendingVideoFramesThreshold || numSequentialPendingVideoFrames > maxSequentialPendingVideoFrames) {                                    long now = System.currentTimeMillis();                                    if (bufferCheckInterval > 0 && now >= nextCheckBufferUnderrun) {                                        sendInsufficientBandwidthStatus(currentItem);                                        nextCheckBufferUnderrun = now + bufferCheckInterval;                                    }                                    videoFrameDropper.dropPacket(rtmpMessage);                                    return;                                }                                if (bufferedInterframeIdx > -1) {                                    IVideoStreamCodec.FrameData fd = videoCodec.getInterframe(bufferedInterframeIdx++);                                    if (fd != null) {                                        VideoData interframe = new VideoData(fd.getFrame());                                        interframe.setTimestamp(body.getTimestamp());                                        rtmpMessage = RTMPMessage.build(interframe);                                    } else {                                        bufferedInterframeIdx = 0;                                    }                                }                            }                        }                    }                } else if (body instanceof AudioData) {                    if (!receiveAudio && sendBlankAudio) {                        sendBlankAudio = false;                        body = new AudioData();                        if (lastMessageTs > 0) {                            body.setTimestamp(lastMessageTs);                        } else {                            body.setTimestamp(0);                        }                        rtmpMessage = RTMPMessage.build(body);                    } else if (!receiveAudio) {                        return;                    }                }                sendMessage(rtmpMessage);            } else {            }        } else if (message instanceof ResetMessage) {            sendReset();        } else {            msgOut.pushMessage(message);        }    }

PlayEngine的pushMessage函数其实很简单，最重要的是最下边的sendMessage函数，剩下的代码就是在根据网络情况判断是否应该发送该数据。sendMessage函数最终会调用doPushMessage函数发送数据，这里就不往下看了。

receiveVideo命令

red5服务器接收到receiveVideo命令后，最终会调用StreamService的receiveVideo方法，代码如下，

    public void receiveVideo(boolean receive) {        IConnection conn = Red5.getConnectionLocal();        if (conn instanceof IStreamCapableConnection) {            IStreamCapableConnection streamConn = (IStreamCapableConnection) conn;            Number streamId = conn.getStreamId();            IClientStream stream = streamConn.getStreamById(streamId);            if (stream != null && stream instanceof ISubscriberStream) {                ISubscriberStream subscriberStream = (ISubscriberStream) stream;                subscriberStream.receiveVideo(receive);            }        }    }

receiveVideo函数其实就是执行PlaylistSubscriberStream的receiveVideo函数，

    public void receiveVideo(boolean receive) {        if (engine != null) {            boolean receiveVideo = engine.receiveVideo(receive);            if (!receiveVideo && receive) {                seekToCurrentPlayback();            }        } else {        }    }

receiveVideo函数最重要的就是调用playEngine的receiveVideo函数进行相应地设置，表示该playEngine可以或者拒绝接收数据。

    public boolean receiveVideo(boolean receive) {        boolean oldValue = receiveVideo;        if (receiveVideo != receive) {            receiveVideo = receive;        }        return oldValue;    }

receiveAudio命令和receiveVideo命令类似，本章就不往下分析了。