Bridger: Support RTC2RTMP bridger and shared FastTimer. 4.0.95

README.md

@@ -157,6 +157,7 @@ Other important wiki:
 
 ## V4 changes
 
+* v5.0, 2021-04-20, Support RTC2RTMP bridger and shared FastTimer. 4.0.95
 * v5.0, 2021-04-20, Refine transcoder to support aac2opus and opus2aac. 4.0.94
 * v4.0, 2021-05-01, Timer: Extract and apply shared FastTimer. 4.0.93
 * v4.0, 2021-04-29, RTC: Support AV1 for Chrome M90. 4.0.91

trunk/conf/full.conf

@@ -571,6 +571,15 @@ vhost rtc.vhost.srs.com {
         #       discard     Discard aac audio packet.
         # default: transcode
         aac transcode;
+        ###############################################################
+        # For transmuxing RTC to RTMP.
+        # Whether trans-mux RTC to RTMP streaming.
+        # Default: off
+        rtc_to_rtmp off;
+        # The PLI interval in seconds, for RTC to RTMP.
+        # Note the available range is [0.5, 30]
+        # Default: 6.0
+        pli_for_rtmp 6.0;
     }
     ###############################################################
     # For transmuxing RTMP to RTC, it will impact the default values if RTC is on.

trunk/src/app/srs_app_config.cpp

@@ -3940,7 +3940,8 @@ srs_error_t SrsConfig::check_normal_config()
                 for (int j = 0; j < (int)conf->directives.size(); j++) {
                     string m = conf->at(j)->name;
                     if (m != "enabled" && m != "bframe" && m != "aac" && m != "stun_timeout" && m != "stun_strict_check"
-                        && m != "dtls_role" && m != "dtls_version" && m != "drop_for_pt") {
+                        && m != "dtls_role" && m != "dtls_version" && m != "drop_for_pt" && m != "rtc_to_rtmp"
+                        && m != "pli_for_rtmp") {
                         return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "illegal vhost.rtc.%s of %s", m.c_str(), vhost->arg0().c_str());
                     }
                 }
@@ -5226,6 +5227,46 @@ int SrsConfig::get_rtc_drop_for_pt(string vhost)
     return ::atoi(conf->arg0().c_str());
 }
 
+bool SrsConfig::get_rtc_to_rtmp(string vhost)
+{
+    static bool DEFAULT = false;
+
+    SrsConfDirective* conf = get_rtc(vhost);
+    if (!conf) {
+        return DEFAULT;
+    }
+
+    conf = conf->get("rtc_to_rtmp");
+    if (!conf || conf->arg0().empty()) {
+        return DEFAULT;
+    }
+
+    return SRS_CONF_PERFER_FALSE(conf->arg0());
+}
+
+srs_utime_t SrsConfig::get_rtc_pli_for_rtmp(string vhost)
+{
+    static srs_utime_t DEFAULT = 6 * SRS_UTIME_SECONDS;
+
+    SrsConfDirective* conf = get_rtc(vhost);
+    if (!conf) {
+        return DEFAULT;
+    }
+
+    conf = conf->get("pli_for_rtmp");
+    if (!conf || conf->arg0().empty()) {
+        return DEFAULT;
+    }
+
+    srs_utime_t v = (srs_utime_t)(::atof(conf->arg0().c_str()) * SRS_UTIME_SECONDS);
+    if (v < 500 * SRS_UTIME_MILLISECONDS || v > 30 * SRS_UTIME_SECONDS) {
+        srs_warn("Reset pli %dms to %dms", srsu2msi(v), srsu2msi(DEFAULT));
+        return DEFAULT;
+    }
+
+    return v;
+}
+
 bool SrsConfig::get_rtc_nack_enabled(string vhost)
 {
     static bool DEFAULT = true;

trunk/src/app/srs_app_config.hpp

@@ -562,6 +562,8 @@ public:
     std::string get_rtc_dtls_role(std::string vhost);
     std::string get_rtc_dtls_version(std::string vhost);
     int get_rtc_drop_for_pt(std::string vhost);
+    bool get_rtc_to_rtmp(std::string vhost);
+    srs_utime_t get_rtc_pli_for_rtmp(std::string vhost);
     bool get_rtc_nack_enabled(std::string vhost);
     bool get_rtc_nack_no_copy(std::string vhost);
     bool get_rtc_twcc_enabled(std::string vhost);

trunk/src/app/srs_app_listener.cpp

@@ -536,6 +536,10 @@ srs_error_t SrsUdpMuxListener::listen()
     
     srs_freep(trd);
     trd = new SrsSTCoroutine("udp", this, cid);
+
+    //change stack size to 256K, fix crash when call some 3rd-part api.
+    ((SrsSTCoroutine*)trd)->set_stack_size(1 << 18);
+
     if ((err = trd->start()) != srs_success) {
         return srs_error_wrap(err, "start thread");
     }

trunk/src/app/srs_app_rtc_conn.cpp

@@ -998,6 +998,28 @@ srs_error_t SrsRtcPublishStream::initialize(SrsRequest* r, SrsRtcStreamDescripti
     }
     source->set_publish_stream(this);
 
+    // Bridge to rtmp
+    bool rtc_to_rtmp = _srs_config->get_rtc_to_rtmp(req->vhost);
+    if (rtc_to_rtmp) {
+        SrsSource *rtmp = NULL;
+        if ((err = _srs_sources->fetch_or_create(r, _srs_hybrid->srs()->instance(), &rtmp)) != srs_success) {
+            return srs_error_wrap(err, "create source");
+        }
+
+        // TODO: FIMXE: Check it in SrsRtcConnection::add_publisher?
+        if (!rtmp->can_publish(false)) {
+            return srs_error_new(ERROR_SYSTEM_STREAM_BUSY, "rtmp stream %s busy", r->get_stream_url().c_str());
+        }
+
+        SrsRtmpFromRtcBridger *bridger = new SrsRtmpFromRtcBridger(rtmp);
+        if ((err = bridger->initialize(r)) != srs_success) {
+            srs_freep(bridger);
+            return srs_error_wrap(err, "create bridger");
+        }
+
+        source->set_bridger(bridger);
+    }
+
     return err;
 }
 

trunk/src/app/srs_app_rtc_source.cpp

@@ -328,6 +328,14 @@ ISrsRtcStreamEventHandler::~ISrsRtcStreamEventHandler()
 {
 }
 
+ISrsRtcSourceBridger::ISrsRtcSourceBridger()
+{
+}
+
+ISrsRtcSourceBridger::~ISrsRtcSourceBridger()
+{
+}
+
 SrsRtcStream::SrsRtcStream()
 {
     is_created_ = false;
@@ -337,6 +345,7 @@ SrsRtcStream::SrsRtcStream()
     stream_desc_ = NULL;
 
     req = NULL;
+    bridger_ = NULL;
 }
 
 SrsRtcStream::~SrsRtcStream()
@@ -346,6 +355,7 @@ SrsRtcStream::~SrsRtcStream()
     consumers.clear();
 
     srs_freep(req);
+    srs_freep(bridger_);
     srs_freep(stream_desc_);
 }
 
@@ -406,6 +416,12 @@ SrsContextId SrsRtcStream::pre_source_id()
     return _pre_source_id;
 }
 
+void SrsRtcStream::set_bridger(ISrsRtcSourceBridger *bridger)
+{
+    srs_freep(bridger_);
+    bridger_ = bridger;
+}
+
 srs_error_t SrsRtcStream::create_consumer(SrsRtcConsumer*& consumer)
 {
     srs_error_t err = srs_success;
@@ -475,6 +491,17 @@ srs_error_t SrsRtcStream::on_publish()
         return srs_error_wrap(err, "source id change");
     }
 
+    // If bridge to other source, handle event and start timer to request PLI.
+    if (bridger_) {
+        if ((err = bridger_->on_publish()) != srs_success) {
+            return srs_error_wrap(err, "bridger on publish");
+        }
+
+        // For SrsRtcStream::on_timer()
+        srs_utime_t pli_for_rtmp = _srs_config->get_rtc_pli_for_rtmp(req->vhost);
+        _srs_hybrid->timer()->subscribe(pli_for_rtmp, this);
+    }
+
     // TODO: FIXME: Handle by statistic.
 
     return err;
@@ -502,6 +529,15 @@ void SrsRtcStream::on_unpublish()
         h->on_unpublish();
     }
 
+    //free bridger resource
+    if (bridger_) {
+        // For SrsRtcStream::on_timer()
+        _srs_hybrid->timer()->unsubscribe(this);
+
+        bridger_->on_unpublish();
+        srs_freep(bridger_);
+    }
+
     // release unpublish stream description.
     set_stream_desc(NULL);
 
@@ -545,6 +581,10 @@ srs_error_t SrsRtcStream::on_rtp(SrsRtpPacket2* pkt)
         }
     }
 
+    if (bridger_ && (err = bridger_->on_rtp(pkt)) != srs_success) {
+        return srs_error_wrap(err, "bridger consume message");
+    }
+
     return err;
 }
 
@@ -586,6 +626,22 @@ std::vector<SrsRtcTrackDescription*> SrsRtcStream::get_track_desc(std::string ty
     return track_descs;
 }
 
+srs_error_t SrsRtcStream::on_timer(srs_utime_t interval, srs_utime_t tick)
+{
+    srs_error_t err = srs_success;
+
+    if (!publish_stream_) {
+        return err;
+    }
+
+    for (int i = 0; i < (int)stream_desc_->video_track_descs_.size(); i++) {
+        SrsRtcTrackDescription* desc = stream_desc_->video_track_descs_.at(i);
+        publish_stream_->request_keyframe(desc->ssrc_);
+    }
+
+    return err;
+}
+
 SrsRtpPacketCacheHelper::SrsRtpPacketCacheHelper()
 {
     pkt = _srs_rtp_cache->allocate();
@@ -1172,6 +1228,473 @@ srs_error_t SrsRtcFromRtmpBridger::consume_packets(vector<SrsRtpPacketCacheHelpe
 
     return err;
 }
+
+SrsRtmpFromRtcBridger::SrsRtmpFromRtcBridger(SrsSource *src)
+{
+    source_ = src;
+    codec_ = NULL;
+    is_first_audio = true;
+    is_first_video = true;
+    format = NULL;
+    key_frame_ts_ = -1;
+    header_sn_ = 0;
+    memset(cache_video_pkts_, 0, sizeof(cache_video_pkts_));
+}
+
+SrsRtmpFromRtcBridger::~SrsRtmpFromRtcBridger()
+{
+    srs_freep(codec_);
+    srs_freep(format);
+    clear_cached_video();
+}
+
+srs_error_t SrsRtmpFromRtcBridger::initialize(SrsRequest* r)
+{
+    srs_error_t err = srs_success;
+
+    codec_ = new SrsAudioTranscoder();
+    format = new SrsRtmpFormat();
+
+    SrsAudioCodecId from = SrsAudioCodecIdOpus; // TODO: From SDP?
+    SrsAudioCodecId to = SrsAudioCodecIdAAC; // The output audio codec.
+    int channels = 2; // The output audio channels.
+    int sample_rate = 48000; // The output audio sample rate in HZ.
+    int bitrate = 48000; // The output audio bitrate in bps.
+    if ((err = codec_->initialize(from, to, channels, sample_rate, bitrate)) != srs_success) {
+        return srs_error_wrap(err, "bridge initialize");
+    }
+
+    if ((err = format->initialize()) != srs_success) {
+        return srs_error_wrap(err, "format initialize");
+    }
+
+    return err;
+}
+
+srs_error_t SrsRtmpFromRtcBridger::on_publish()
+{
+    srs_error_t err = srs_success;
+
+    is_first_audio = true;
+    is_first_video = true;
+
+    // TODO: FIXME: Should sync with bridger?
+    if ((err = source_->on_publish()) != srs_success) {
+        return srs_error_wrap(err, "source publish");
+    }
+
+    return err;
+}
+
+srs_error_t SrsRtmpFromRtcBridger::on_rtp(SrsRtpPacket2 *pkt)
+{
+    srs_error_t err = srs_success;
+
+    if (!pkt->payload()) {
+        return err;
+    }
+
+    if (pkt->is_audio()) {
+        err = trancode_audio(pkt);
+    } else {
+        err = packet_video(pkt);
+    }
+
+    return err;
+}
+
+void SrsRtmpFromRtcBridger::on_unpublish()
+{
+    // TODO: FIXME: Should sync with bridger?
+    source_->on_unpublish();
+}
+
+srs_error_t SrsRtmpFromRtcBridger::trancode_audio(SrsRtpPacket2 *pkt)
+{
+    srs_error_t err = srs_success;
+
+    // to common message.
+    uint32_t ts = pkt->header.get_timestamp()/(48000/1000);
+    if (is_first_audio) {
+        int header_len = 0;
+        uint8_t* header = NULL;
+        codec_->aac_codec_header(&header, &header_len);
+
+        SrsCommonMessage out_rtmp;
+        packet_aac(&out_rtmp, (char *)header, header_len, ts, is_first_audio);
+
+        if ((err = source_->on_audio(&out_rtmp)) != srs_success) {
+            return srs_error_wrap(err, "source on audio");
+        }
+
+        is_first_audio = false;
+    }
+
+    std::vector<SrsAudioFrame *> out_pkts;
+    SrsRtpRawPayload *payload = dynamic_cast<SrsRtpRawPayload *>(pkt->payload());
+
+    SrsAudioFrame frame;
+    frame.add_sample(payload->payload, payload->nn_payload);
+    frame.dts = ts;
+    frame.cts = 0;
+
+    err = codec_->transcode(&frame, out_pkts);
+    if (err != srs_success) {
+        return err;
+    }
+
+    for (std::vector<SrsAudioFrame *>::iterator it = out_pkts.begin(); it != out_pkts.end(); ++it) {
+        SrsCommonMessage out_rtmp;
+        out_rtmp.header.timestamp = (*it)->dts*(48000/1000);
+        packet_aac(&out_rtmp, (*it)->samples[0].bytes, (*it)->samples[0].size, ts, is_first_audio);
+
+        if ((err = source_->on_audio(&out_rtmp)) != srs_success) {
+            err = srs_error_wrap(err, "source on audio");
+            break;
+        }
+    }
+    codec_->free_frames(out_pkts);
+
+    return err;
+}
+
+void SrsRtmpFromRtcBridger::packet_aac(SrsCommonMessage* audio, char* data, int len, uint32_t pts, bool is_header)
+{
+    int rtmp_len = len + 2;
+    audio->header.initialize_audio(rtmp_len, pts, 1);
+    audio->create_payload(rtmp_len);
+    SrsBuffer stream(audio->payload, rtmp_len);
+    uint8_t aac_flag = (SrsAudioCodecIdAAC << 4) | (SrsAudioSampleRate44100 << 2) | (SrsAudioSampleBits16bit << 1) | SrsAudioChannelsStereo;
+    stream.write_1bytes(aac_flag);
+    if (is_header) {
+        stream.write_1bytes(0);
+    } else {
+        stream.write_1bytes(1);
+    }
+    stream.write_bytes(data, len);
+    audio->size = rtmp_len;
+}
+
+srs_error_t SrsRtmpFromRtcBridger::packet_video(SrsRtpPacket2* src)
+{
+    srs_error_t err = srs_success;
+
+    // TODO: Only copy when need
+    SrsRtpPacket2* pkt = src->copy();
+
+    if (pkt->is_keyframe()) {
+        return packet_video_key_frame(pkt);
+    }
+
+    // store in cache
+    int index = cache_index(pkt->header.get_sequence());
+    cache_video_pkts_[index].in_use = true;
+    cache_video_pkts_[index].pkt = pkt;
+    cache_video_pkts_[index].sn = pkt->header.get_sequence();
+    cache_video_pkts_[index].ts = pkt->header.get_timestamp();
+
+    // check whether to recovery lost packet and can construct a video frame
+    if (lost_sn_ == pkt->header.get_sequence()) {
+        uint16_t tail_sn = 0;
+        int sn = find_next_lost_sn(lost_sn_, tail_sn);
+        if (-1 == sn ) {
+            if (check_frame_complete(header_sn_, tail_sn)) {
+                if ((err = packet_video_rtmp(header_sn_, tail_sn)) != srs_success) {
+                    err = srs_error_wrap(err, "fail to pack video frame");
+                }
+            }
+        } else if (-2 == sn) {
+            return srs_error_new(ERROR_RTC_RTP_MUXER, "video cache is overflow");
+        } else {
+            lost_sn_ = (uint16_t)sn;
+        }
+    }
+
+    return err;
+}
+
+srs_error_t SrsRtmpFromRtcBridger::packet_video_key_frame(SrsRtpPacket2* pkt)
+{
+    srs_error_t err = srs_success;
+
+    // TODO: handle sps and pps in 2 rtp packets
+    SrsRtpSTAPPayload* stap_payload = dynamic_cast<SrsRtpSTAPPayload*>(pkt->payload());
+    if (stap_payload) {
+        SrsSample* sps = stap_payload->get_sps();
+        SrsSample* pps = stap_payload->get_pps();
+        if (NULL == sps || NULL == pps) {
+            return srs_error_new(ERROR_RTC_RTP_MUXER, "no sps or pps in stap-a rtp. sps: %p, pps:%p", sps, pps);
+        } else {
+            //type_codec1 + avc_type + composition time + fix header + count of sps + len of sps + sps + count of pps + len of pps + pps
+            int nb_payload = 1 + 1 + 3 + 5 + 1 + 2 + sps->size + 1 + 2 + pps->size;
+            SrsCommonMessage rtmp;
+            rtmp.header.initialize_video(nb_payload, pkt->header.get_timestamp() / 90, 1);
+            rtmp.create_payload(nb_payload);
+            rtmp.size = nb_payload;
+            SrsBuffer payload(rtmp.payload, rtmp.size);
+            //TODO: call api
+            payload.write_1bytes(0x17);// type(4 bits): key frame; code(4bits): avc
+            payload.write_1bytes(0x0); // avc_type: sequence header
+            payload.write_1bytes(0x0); // composition time
+            payload.write_1bytes(0x0);
+            payload.write_1bytes(0x0);
+            payload.write_1bytes(0x01); // version
+            payload.write_1bytes(sps->bytes[1]);
+            payload.write_1bytes(sps->bytes[2]);
+            payload.write_1bytes(sps->bytes[3]);
+            payload.write_1bytes(0xff);
+            payload.write_1bytes(0xe1);
+            payload.write_2bytes(sps->size);
+            payload.write_bytes(sps->bytes, sps->size);
+            payload.write_1bytes(0x01);
+            payload.write_2bytes(pps->size);
+            payload.write_bytes(pps->bytes, pps->size);
+            if ((err = source_->on_video(&rtmp)) != srs_success) {
+                return err;
+            }
+        }
+    }
+
+    if (-1 == key_frame_ts_) {
+        key_frame_ts_ = pkt->header.get_timestamp();
+        header_sn_ = pkt->header.get_sequence();
+        lost_sn_ = header_sn_ + 1;
+        // Received key frame and clean cache of old p frame pkts
+        clear_cached_video();
+        srs_trace("set ts=%lld, header=%hu, lost=%hu", key_frame_ts_, header_sn_, lost_sn_);
+    } else if (key_frame_ts_ != pkt->header.get_timestamp()) {
+        //new key frame, clean cache
+        int64_t old_ts = key_frame_ts_;
+        uint16_t old_header_sn = header_sn_;
+        uint16_t old_lost_sn = lost_sn_;
+        key_frame_ts_ = pkt->header.get_timestamp();
+        header_sn_ = pkt->header.get_sequence();
+        lost_sn_ = header_sn_ + 1;
+        clear_cached_video();
+        srs_trace("drop old ts=%lld, header=%hu, lost=%hu, set new ts=%lld, header=%hu, lost=%hu",
+            old_ts, old_header_sn, old_lost_sn, key_frame_ts_, header_sn_, lost_sn_);
+    }
+
+    uint16_t index = cache_index(pkt->header.get_sequence());
+    cache_video_pkts_[index].in_use = true;
+    cache_video_pkts_[index].pkt = pkt;
+    cache_video_pkts_[index].sn = pkt->header.get_sequence();
+    cache_video_pkts_[index].ts = pkt->header.get_timestamp();
+
+    int32_t sn = lost_sn_;
+    uint16_t tail_sn = 0;
+    if (srs_rtp_seq_distance(header_sn_, pkt->header.get_sequence()) < 0){
+        // When receive previous pkt in the same frame, update header sn;
+        header_sn_ = pkt->header.get_sequence();
+        sn = find_next_lost_sn(header_sn_, tail_sn);
+    } else if (lost_sn_ == pkt->header.get_sequence()) {
+        sn = find_next_lost_sn(lost_sn_, tail_sn);
+    }
+
+    if (-1 == sn) {
+        if (check_frame_complete(header_sn_, tail_sn)) {
+            if ((err = packet_video_rtmp(header_sn_, tail_sn)) != srs_success) {
+                err = srs_error_wrap(err, "fail to packet key frame");
+            }
+        }
+    } else if (-2 == sn) {
+        return srs_error_new(ERROR_RTC_RTP_MUXER, "video cache is overflow");
+    } else {
+        lost_sn_ = (uint16_t)sn;
+    }
+
+    return err;
+}
+
+srs_error_t SrsRtmpFromRtcBridger::packet_video_rtmp(const uint16_t start, const uint16_t end)
+{
+    srs_error_t err = srs_success;
+
+    //type_codec1 + avc_type + composition time + nalu size + nalu
+    int nb_payload = 1 + 1 + 3;
+    uint16_t cnt = end - start + 1;
+
+    for (uint16_t i = 0; i < cnt; ++i) {
+        uint16_t sn = start + i;
+        uint16_t index = cache_index(sn);
+        SrsRtpPacket2* pkt = cache_video_pkts_[index].pkt;
+        // calculate nalu len
+        SrsRtpFUAPayload2* fua_payload = dynamic_cast<SrsRtpFUAPayload2*>(pkt->payload());
+        if (fua_payload) {
+            if (fua_payload->start) {
+                nb_payload += 1 + 4;
+            }
+            nb_payload += fua_payload->size;
+            continue;
+        }
+
+        SrsRtpSTAPPayload* stap_payload = dynamic_cast<SrsRtpSTAPPayload*>(pkt->payload());
+        if (stap_payload) {
+            for (int j = 0; j < stap_payload->nalus.size(); ++j) {
+                SrsSample* sample = stap_payload->nalus.at(j);
+                nb_payload += 4 + sample->size;
+            }
+            continue;
+        }
+
+        SrsRtpRawPayload* raw_payload = dynamic_cast<SrsRtpRawPayload*>(pkt->payload());
+        if (raw_payload) {
+            nb_payload += 4 + raw_payload->nn_payload;
+            continue;
+        }
+    }
+
+    SrsCommonMessage rtmp;
+    SrsRtpPacket2* header = cache_video_pkts_[cache_index(start)].pkt;
+    rtmp.header.initialize_video(nb_payload, header->header.get_timestamp() / 90, 1);
+    rtmp.create_payload(nb_payload);
+    rtmp.size = nb_payload;
+    SrsBuffer payload(rtmp.payload, rtmp.size);
+    if (header->is_keyframe()) {
+        payload.write_1bytes(0x17); // type(4 bits): key frame; code(4bits): avc
+        key_frame_ts_ = -1;
+    } else {
+        payload.write_1bytes(0x27); // type(4 bits): inter frame; code(4bits): avc
+    }
+    payload.write_1bytes(0x01); // avc_type: nalu
+    payload.write_1bytes(0x0);  // composition time
+    payload.write_1bytes(0x0);
+    payload.write_1bytes(0x0);
+
+    int nalu_len = 0;
+    for (uint16_t i = 0; i < cnt; ++i) {
+        uint16_t index = cache_index((start + i));
+        SrsRtpPacket2* pkt = cache_video_pkts_[index].pkt;
+        cache_video_pkts_[index].in_use = false;
+        cache_video_pkts_[index].pkt = NULL;
+        cache_video_pkts_[index].ts = 0;
+        cache_video_pkts_[index].sn = 0;
+
+        SrsRtpFUAPayload2* fua_payload = dynamic_cast<SrsRtpFUAPayload2*>(pkt->payload());
+        if (fua_payload) {
+            if (fua_payload->start) {
+                nalu_len = fua_payload->size + 1;
+                //skip 4 bytes to write nalu_len future
+                payload.skip(4);
+                payload.write_1bytes(fua_payload->nri | fua_payload->nalu_type);
+                payload.write_bytes(fua_payload->payload, fua_payload->size);
+            } else {
+                nalu_len += fua_payload->size;
+                payload.write_bytes(fua_payload->payload, fua_payload->size);
+                if (fua_payload->end) {
+                    //write nalu_len back
+                    payload.skip(-(4 + nalu_len));
+                    payload.write_4bytes(nalu_len);
+                    payload.skip(nalu_len);
+                }
+            }
+            srs_freep(pkt);
+            continue;
+        }
+
+        SrsRtpSTAPPayload* stap_payload = dynamic_cast<SrsRtpSTAPPayload*>(pkt->payload());
+        if (stap_payload) {
+            for (int j = 0; j < stap_payload->nalus.size(); ++j) {
+                SrsSample* sample = stap_payload->nalus.at(j);
+                payload.write_4bytes(sample->size);
+                payload.write_bytes(sample->bytes, sample->size);
+            }
+            srs_freep(pkt);
+            continue;
+        }
+
+        SrsRtpRawPayload* raw_payload = dynamic_cast<SrsRtpRawPayload*>(pkt->payload());
+        if (raw_payload) {
+            payload.write_4bytes(raw_payload->nn_payload);
+            payload.write_bytes(raw_payload->payload, raw_payload->nn_payload);
+            srs_freep(pkt);
+            continue;
+        }
+
+        srs_freep(pkt);
+    }
+
+    if ((err = source_->on_video(&rtmp)) != srs_success) {
+        srs_warn("fail to pack video frame");
+    }
+
+    header_sn_ = end + 1;
+    uint16_t tail_sn = 0;
+    int sn = find_next_lost_sn(header_sn_, tail_sn);
+    if (-1 == sn) {
+        if (check_frame_complete(header_sn_, tail_sn)) {
+            err = packet_video_rtmp(header_sn_, tail_sn);
+        }
+    } else if (-2 == sn) {
+        return srs_error_new(ERROR_RTC_RTP_MUXER, "video cache is overflow");
+    } else {
+        lost_sn_ = sn;
+    }
+
+    return err;
+}
+
+int32_t SrsRtmpFromRtcBridger::find_next_lost_sn(uint16_t current_sn, uint16_t& end_sn)
+{
+    uint32_t last_ts = cache_video_pkts_[cache_index(header_sn_)].ts;
+    for (int i = 0; i < s_cache_size; ++i) {
+        uint16_t lost_sn = current_sn + i;
+        int index = cache_index(lost_sn);
+
+        if (!cache_video_pkts_[index].in_use) {
+            return lost_sn;
+        }
+        //check time first, avoid two small frame mixed case decode fail
+        if (last_ts != cache_video_pkts_[index].ts) {
+            end_sn = lost_sn - 1;
+            return -1;
+        }
+
+        if (cache_video_pkts_[index].pkt->header.get_marker()) {
+            end_sn = lost_sn;
+            return -1;
+        }
+    }
+
+    srs_error("the cache is mess. the packet count of video frame is more than %u", s_cache_size);
+    return -2;
+}
+
+void SrsRtmpFromRtcBridger::clear_cached_video()
+{
+    for (size_t i = 0; i < s_cache_size; i++)
+    {
+        if (cache_video_pkts_[i].in_use) {
+            srs_freep(cache_video_pkts_[i].pkt);
+            cache_video_pkts_[i].sn = 0;
+            cache_video_pkts_[i].ts = 0;
+            cache_video_pkts_[i].in_use = false;
+        }
+    }
+}
+
+bool SrsRtmpFromRtcBridger::check_frame_complete(const uint16_t start, const uint16_t end)
+{
+    uint16_t cnt = (end - start + 1);
+    uint16_t fu_s_c = 0;
+    uint16_t fu_e_c = 0;
+    for (uint16_t i = 0; i < cnt; ++i) {
+        int index = cache_index((start + i));
+        SrsRtpPacket2* pkt = cache_video_pkts_[index].pkt;
+        SrsRtpFUAPayload2* fua_payload = dynamic_cast<SrsRtpFUAPayload2*>(pkt->payload());
+        if (fua_payload) {
+            if (fua_payload->start) {
+                ++fu_s_c;
+            }
+
+            if (fua_payload->end) {
+                ++fu_e_c;
+            }
+        }
+    }
+
+    return fu_s_c == fu_e_c;
+}
 #endif
 
 SrsCodecPayload::SrsCodecPayload()

trunk/src/app/srs_app_rtc_source.hpp

@@ -163,8 +163,20 @@ public:
     virtual void on_consumers_finished() = 0;
 };
 
+// SrsRtcStream bridge to SrsSource
+class ISrsRtcSourceBridger
+{
+public:
+    ISrsRtcSourceBridger();
+    virtual ~ISrsRtcSourceBridger();
+public:
+    virtual srs_error_t on_publish() = 0;
+    virtual srs_error_t on_rtp(SrsRtpPacket2 *pkt) = 0;
+    virtual void on_unpublish() = 0;
+};
+
 // A Source is a stream, to publish and to play with, binding to SrsRtcPublishStream and SrsRtcPlayStream.
-class SrsRtcStream
+class SrsRtcStream : public ISrsFastTimer
 {
 private:
     // For publish, it's the publish client id.
@@ -178,6 +190,8 @@ private:
     ISrsRtcPublishStream* publish_stream_;
     // Steam description for this steam.
     SrsRtcStreamDescription* stream_desc_;
+    // The Source bridger, bridger stream to other source.
+    ISrsRtcSourceBridger* bridger_;
 private:
     // To delivery stream to clients.
     std::vector<SrsRtcConsumer*> consumers;
@@ -201,6 +215,8 @@ public:
     // Get current source id.
     virtual SrsContextId source_id();
     virtual SrsContextId pre_source_id();
+public:
+    void set_bridger(ISrsRtcSourceBridger *bridger);
 public:
     // Create consumer
     // @param consumer, output the create consumer.
@@ -234,6 +250,9 @@ public:
     bool has_stream_desc();
     void set_stream_desc(SrsRtcStreamDescription* stream_desc);
     std::vector<SrsRtcTrackDescription*> get_track_desc(std::string type, std::string media_type);
+// interface ISrsFastTimer
+private:
+    srs_error_t on_timer(srs_utime_t interval, srs_utime_t tick);
 };
 
 // A helper class, to release the packet to cache.
@@ -286,6 +305,52 @@ private:
     srs_error_t package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, std::vector<SrsRtpPacketCacheHelper*>& helpers);
     srs_error_t consume_packets(std::vector<SrsRtpPacketCacheHelper*>& helpers);
 };
+
+class SrsRtmpFromRtcBridger : public ISrsRtcSourceBridger
+{
+private:
+    SrsSource *source_;
+    SrsAudioTranscoder *codec_;
+    bool is_first_audio;
+    bool is_first_video;
+    // The format, codec information.
+    SrsRtmpFormat* format;
+
+    //TODO:use SrsRtpRingBuffer
+    //TODO:jitter buffer class
+    struct RtcPacketCache {
+        bool in_use;
+        uint16_t sn;
+        uint32_t ts;
+        SrsRtpPacket2* pkt;
+    };
+    const static uint16_t s_cache_size = 512;
+    RtcPacketCache cache_video_pkts_[s_cache_size];
+    uint16_t header_sn_;
+    uint16_t lost_sn_;
+    int64_t key_frame_ts_;
+public:
+    SrsRtmpFromRtcBridger(SrsSource *src);
+    virtual ~SrsRtmpFromRtcBridger();
+public:
+    srs_error_t initialize(SrsRequest* r);
+public:
+    virtual srs_error_t on_publish();
+    virtual srs_error_t on_rtp(SrsRtpPacket2 *pkt);
+    virtual void on_unpublish();
+private:
+    srs_error_t trancode_audio(SrsRtpPacket2 *pkt);
+    void packet_aac(SrsCommonMessage* audio, char* data, int len, uint32_t pts, bool is_header);
+    srs_error_t packet_video(SrsRtpPacket2* pkt);
+    srs_error_t packet_video_key_frame(SrsRtpPacket2* pkt);
+    srs_error_t packet_video_rtmp(const uint16_t start, const uint16_t end);
+    int32_t find_next_lost_sn(uint16_t current_sn, uint16_t& end_sn);
+    void clear_cached_video();
+    inline uint16_t cache_index(uint16_t current_sn) {
+        return current_sn%s_cache_size;
+    }
+    bool check_frame_complete(const uint16_t start, const uint16_t end);
+};
 #endif
 
 // TODO: FIXME: Rename it.

trunk/src/app/srs_app_source.hpp

@@ -487,7 +487,7 @@ public:
 // Global singleton instance.
 extern SrsSourceManager* _srs_sources;
 
-// For two sources to bridge with each other.
+// For RTMP2RTC, bridge SrsSource to SrsRtcStream
 class ISrsSourceBridger
 {
 public:

trunk/src/core/srs_core_version4.hpp

@@ -26,6 +26,6 @@
 
 #define VERSION_MAJOR       4
 #define VERSION_MINOR       0
-#define VERSION_REVISION    94
+#define VERSION_REVISION    95
 
 #endif

trunk/src/kernel/srs_kernel_rtc_rtp.cpp

@@ -1054,6 +1054,33 @@ srs_error_t SrsRtpPacket2::decode(SrsBuffer* buf)
     return err;
 }
 
+bool SrsRtpPacket2::is_keyframe()
+{
+    // False if audio packet
+    if(SrsFrameTypeAudio == frame_type) {
+        return false;
+    }
+
+    // It's normal H264 video rtp packet
+    if (nalu_type == kStapA) {
+        SrsRtpSTAPPayload* stap_payload = dynamic_cast<SrsRtpSTAPPayload*>(payload_);
+        if(NULL != stap_payload->get_sps() || NULL != stap_payload->get_pps()) {
+            return true;
+        }
+    } else if (nalu_type == kFuA) {
+        SrsRtpFUAPayload2* fua_payload = dynamic_cast<SrsRtpFUAPayload2*>(payload_);
+        if(SrsAvcNaluTypeIDR == fua_payload->nalu_type) {
+            return true;
+        }
+    } else {
+        if((SrsAvcNaluTypeIDR == nalu_type) || (SrsAvcNaluTypeSPS == nalu_type) || (SrsAvcNaluTypePPS == nalu_type)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 SrsRtpObjectCacheManager<SrsRtpPacket2>* _srs_rtp_cache = new SrsRtpObjectCacheManager<SrsRtpPacket2>(sizeof(SrsRtpPacket2));
 SrsRtpObjectCacheManager<SrsRtpRawPayload>* _srs_rtp_raw_cache = new SrsRtpObjectCacheManager<SrsRtpRawPayload>(sizeof(SrsRtpRawPayload));
 SrsRtpObjectCacheManager<SrsRtpFUAPayload2>* _srs_rtp_fua_cache = new SrsRtpObjectCacheManager<SrsRtpFUAPayload2>(sizeof(SrsRtpFUAPayload2));

trunk/src/kernel/srs_kernel_rtc_rtp.hpp

@@ -353,6 +353,8 @@ public:
     virtual uint64_t nb_bytes();
     virtual srs_error_t encode(SrsBuffer* buf);
     virtual srs_error_t decode(SrsBuffer* buf);
+public:
+    bool is_keyframe();
 };
 
 // For object cache manager to stat the object dropped.