bool BaseOutRecording::IsCompatibleWithType(uint64_t type) {
return TAG_KIND_OF(type, ST_IN_NET_RTMP)
|| TAG_KIND_OF(type, ST_IN_NET_RTP)
|| TAG_KIND_OF(type, ST_IN_NET_TS)
|| TAG_KIND_OF(type, ST_IN_NET_LIVEFLV)
|| TAG_KIND_OF(type, ST_IN_FILE);
}
bool OutNetRTMP4TSStream::IsCompatibleWithType(uint64_t type) {
_inboundStreamIsRTP = TAG_KIND_OF(type, ST_IN_NET_RTP);
_videoCodecSent = (type == ST_IN_NET_AAC);
return TAG_KIND_OF(type, ST_IN_NET_TS)
|| TAG_KIND_OF(type, ST_IN_NET_RTP)
|| TAG_KIND_OF(type, ST_IN_NET_AAC);
}
bool InNetLiveFLVStream::SendStreamMessage(Variant &completeMessage, bool persistent) {
//2. Loop on the subscribed streams and send the message
LinkedListNode<BaseOutStream *> *pTemp = _pOutStreams;
while ((pTemp != NULL) && (!IsEnqueueForDelete())) {
if (pTemp->info->IsEnqueueForDelete()) {
continue;
}
if (TAG_KIND_OF(pTemp->info->GetType(), ST_OUT_NET_RTMP)) {
if (!((BaseOutNetRTMPStream *) pTemp->info)->SendStreamMessage(completeMessage)) {
FATAL("Unable to send notify on stream. The connection will go down");
pTemp->info->EnqueueForDelete();
}
}
pTemp = pTemp->pPrev;
}
//3. Test to see if we are still alive. One of the target streams might
//be on the same RTMP connection as this stream is and our connection
//here might be enque for delete
if (IsEnqueueForDelete())
return false;
//4. Save the message for future use if necessary
if (persistent)
_lastStreamMessage = completeMessage;
//5. Done
return true;
}
BaseInFileStream::BaseInFileStream(BaseProtocol *pProtocol,
StreamsManager *pStreamsManager, uint64_t type, string name)
: BaseInStream(pProtocol, pStreamsManager, type, name) {
if (!TAG_KIND_OF(type, ST_IN_FILE)) {
ASSERT("Incorrect stream type. Wanted a stream type in class %s and got %s",
STR(tagToString(ST_IN_FILE)), STR(tagToString(type)));
}
_pTimer = NULL;
_pSeekFile = NULL;
_pFile = NULL;
//frame info
_totalFrames = 0;
_currentFrameIndex = 0;
memset(&_currentFrame, 0, sizeof (MediaFrame));
//timing info
_totalSentTime = 0;
_totalSentTimeBase = 0;
_startFeedingTime = 0;
//buffering info
_clientSideBufferLength = 0;
//current state info
_paused = true;
_audioVideoCodecsSent = false;
}
BaseInNetStream::BaseInNetStream(BaseProtocol *pProtocol, uint64_t type, string name)
: BaseInStream(pProtocol, type, name) {
if (!TAG_KIND_OF(type, ST_IN_NET)) {
ASSERT("Incorrect stream type. Wanted a stream type in class %s and got %s",
STR(tagToString(ST_IN_NET)), STR(tagToString(type)));
}
}
void InFileRTMPStream::SignalOutStreamAttached(BaseOutStream *pOutStream) {
//2. Set a big chunk size on the corresponding connection
if (TAG_KIND_OF(pOutStream->GetType(), ST_OUT_NET_RTMP)) {
((BaseRTMPProtocol *) pOutStream->GetProtocol())->TrySetOutboundChunkSize(_chunkSize);
((BaseOutNetRTMPStream *) pOutStream)->SetFeederChunkSize(_chunkSize);
((BaseOutNetRTMPStream *) pOutStream)->CanDropFrames(false);
}
}
InFileRTMPStream::InFileRTMPStream(BaseProtocol *pProtocol,
StreamsManager *pStreamsManager, uint64_t type, string name)
: BaseInFileStream(pProtocol, pStreamsManager, type, name) {
if (!TAG_KIND_OF(type, ST_IN_FILE_RTMP)) {
ASSERT("Incorrect stream type. Wanted a stream type in class %s and got %s",
STR(tagToString(ST_IN_FILE_RTMP)), STR(tagToString(type)));
}
_chunkSize = 4 * 1024 * 1024;
}
BaseInStream::BaseInStream(BaseProtocol *pProtocol, uint64_t type, string name)
: BaseStream(pProtocol, type, name) {
if (!TAG_KIND_OF(type, ST_IN)) {
ASSERT("Incorrect stream type. Wanted a stream type in class %s and got %s",
STR(tagToString(ST_IN)), STR(tagToString(type)));
}
_pOutStreams = NULL;
_canCallOutStreamDetached = true;
}
BaseOutStream::BaseOutStream(BaseProtocol *pProtocol,
StreamsManager *pStreamsManager, uint64_t type, string name)
: BaseStream(pProtocol, pStreamsManager, type, name) {
if (!TAG_KIND_OF(type, ST_OUT)) {
ASSERT("Incorrect stream type. Wanted a stream type in class %s and got %s",
STR(tagToString(ST_OUT)), STR(tagToString(type)));
}
_canCallDetachedFromInStream = true;
_pInStream = NULL;
}
void InNetLiveFLVStream::SignalOutStreamAttached(BaseOutStream *pOutStream) {
if (_lastStreamMessage != V_NULL) {
if (TAG_KIND_OF(pOutStream->GetType(), ST_OUT_NET_RTMP)) {
if (!((BaseOutNetRTMPStream *) pOutStream)->SendStreamMessage(
_lastStreamMessage)) {
FATAL("Unable to send notify on stream. The connection will go down");
pOutStream->EnqueueForDelete();
}
}
}
}
BaseInFileStream::BaseInFileStream(BaseProtocol *pProtocol,
StreamsManager *pStreamsManager, uint64_t type, string name)
: BaseInStream(pProtocol, pStreamsManager, type, name) {
if (!TAG_KIND_OF(type, ST_IN_FILE)) {
ASSERT("Incorrect stream type. Wanted a stream type in class %s and got %s",
STR(tagToString(ST_IN_FILE)), STR(tagToString(type)));
}
_pTimer = NULL;
_pSeekFile = NULL;
_pFile = NULL;
//frame info
_totalFrames = 0;
_currentFrameIndex = 0;
memset(&_currentFrame, 0, sizeof (MediaFrame));
//timing info
_totalSentTime = 0;
_totalSentTimeBase = 0;
_startFeedingTime = 0;
//buffering info
_clientSideBufferLength = 0;
//current state info
_streamingState = FILE_STREAMING_STATE_PAUSED;
_audioVideoCodecsSent = false;
_seekBaseOffset = 0;
_framesBaseOffset = 0;
_timeToIndexOffset = 0;
_streamCapabilities.Clear();
_playLimit = -1;
}
bool InNetTSStream::IsCompatibleWithType(uint64_t type) {
return TAG_KIND_OF(type, ST_OUT_NET_RTMP_4_TS)
|| (type == ST_OUT_NET_RTP);
}
bool InFileRTMPStream::IsCompatibleWithType(uint64_t type) {
return TAG_KIND_OF(type, ST_OUT_NET_RTMP);
}
bool InNetLiveFLVStream::IsCompatibleWithType(uint64_t type) {
return TAG_KIND_OF(type, ST_OUT_NET_RTMP)
|| TAG_KIND_OF(type, ST_OUT_NET_RTP)
;
}
bool OutNetRTMP4RTMPStream::IsCompatibleWithType(uint64_t type) {
return TAG_KIND_OF(type, ST_IN_NET_RTMP)
|| TAG_KIND_OF(type, ST_IN_NET_LIVEFLV)
|| TAG_KIND_OF(type, ST_IN_FILE_RTMP)
|| TAG_KIND_OF(type, ST_IN_NET_MP3);
}
