diff --git a/trunk/Dockerfile.cov b/trunk/Dockerfile.cov
index d3ff9d8eb..0e33e1307 100644
--- a/trunk/Dockerfile.cov
+++ b/trunk/Dockerfile.cov
@@ -16,6 +16,6 @@ COPY . /srs
 WORKDIR /srs/trunk
 
 # Note that we must enable the gcc7 or link failed.
-RUN ./configure --srt=on --gb28181=on --apm=on --h265=on --utest=on --gcov=on --sanitizer=on
+RUN ./configure --rtsp=on --srt=on --gb28181=on --apm=on --h265=on --utest=on --gcov=on --sanitizer=on
 RUN make utest ${MAKEARGS}
 
diff --git a/trunk/configure b/trunk/configure
index dec87c088..93a0337f7 100755
--- a/trunk/configure
+++ b/trunk/configure
@@ -381,8 +381,8 @@ if [[ $SRS_UTEST == YES ]]; then
         "srs_utest_config3" "srs_utest_config4" "srs_utest_protocol" "srs_utest_protocol2" "srs_utest_kernel2"
         "srs_utest_st" "srs_utest_rtc2" "srs_utest_rtc3" "srs_utest_fmp4" "srs_utest_source_lock"
         "srs_utest_stream_token" "srs_utest_rtc_recv_track" "srs_utest_st2" "srs_utest_hevc_structs"
-        "srs_utest_coworkers" "srs_utest_pithy_print" "srs_utest_kernel3" "srs_utest_protocol4" 
-        "srs_utest_protocol3")
+        "srs_utest_coworkers" "srs_utest_pithy_print" "srs_utest_kernel3" "srs_utest_protocol4"
+        "srs_utest_protocol3" "srs_utest_app3")
     # Always include SRT utest
     MODULE_FILES+=("srs_utest_srt")
     if [[ $SRS_GB28181 == YES ]]; then
diff --git a/trunk/src/utest/srs_utest_app2.cpp b/trunk/src/utest/srs_utest_app2.cpp
index 05c5bccff..661120778 100644
--- a/trunk/src/utest/srs_utest_app2.cpp
+++ b/trunk/src/utest/srs_utest_app2.cpp
@@ -241,6 +241,113 @@ public:
     }
 };
 
+// Mock implementation of ISrsRtcBridge for testing
+class MockRtcBridge : public ISrsRtcBridge
+{
+public:
+    int initialize_count_;
+    int setup_codec_count_;
+    int on_publish_count_;
+    int on_unpublish_count_;
+    int on_rtp_count_;
+
+    srs_error_t initialize_error_;
+    srs_error_t setup_codec_error_;
+    srs_error_t on_publish_error_;
+    srs_error_t on_rtp_error_;
+
+    ISrsRequest *last_initialize_req_;
+    SrsAudioCodecId last_audio_codec_;
+    SrsVideoCodecId last_video_codec_;
+    SrsRtpPacket *last_rtp_packet_;
+
+    MockRtcBridge()
+    {
+        initialize_count_ = 0;
+        setup_codec_count_ = 0;
+        on_publish_count_ = 0;
+        on_unpublish_count_ = 0;
+        on_rtp_count_ = 0;
+
+        initialize_error_ = srs_success;
+        setup_codec_error_ = srs_success;
+        on_publish_error_ = srs_success;
+        on_rtp_error_ = srs_success;
+
+        last_initialize_req_ = NULL;
+        last_audio_codec_ = SrsAudioCodecIdForbidden;
+        last_video_codec_ = SrsVideoCodecIdForbidden;
+        last_rtp_packet_ = NULL;
+    }
+
+    virtual ~MockRtcBridge()
+    {
+        srs_freep(initialize_error_);
+        srs_freep(setup_codec_error_);
+        srs_freep(on_publish_error_);
+        srs_freep(on_rtp_error_);
+        srs_freep(last_rtp_packet_);
+    }
+
+    virtual srs_error_t initialize(ISrsRequest *r)
+    {
+        initialize_count_++;
+        last_initialize_req_ = r;
+        return srs_error_copy(initialize_error_);
+    }
+
+    virtual srs_error_t setup_codec(SrsAudioCodecId acodec, SrsVideoCodecId vcodec)
+    {
+        setup_codec_count_++;
+        last_audio_codec_ = acodec;
+        last_video_codec_ = vcodec;
+        return srs_error_copy(setup_codec_error_);
+    }
+
+    virtual srs_error_t on_publish()
+    {
+        on_publish_count_++;
+        return srs_error_copy(on_publish_error_);
+    }
+
+    virtual void on_unpublish()
+    {
+        on_unpublish_count_++;
+    }
+
+    virtual srs_error_t on_rtp(SrsRtpPacket *pkt)
+    {
+        on_rtp_count_++;
+        srs_freep(last_rtp_packet_);
+        last_rtp_packet_ = pkt->copy();
+        return srs_error_copy(on_rtp_error_);
+    }
+
+    void set_initialize_error(srs_error_t err)
+    {
+        srs_freep(initialize_error_);
+        initialize_error_ = srs_error_copy(err);
+    }
+
+    void set_setup_codec_error(srs_error_t err)
+    {
+        srs_freep(setup_codec_error_);
+        setup_codec_error_ = srs_error_copy(err);
+    }
+
+    void set_on_publish_error(srs_error_t err)
+    {
+        srs_freep(on_publish_error_);
+        on_publish_error_ = srs_error_copy(err);
+    }
+
+    void set_on_rtp_error(srs_error_t err)
+    {
+        srs_freep(on_rtp_error_);
+        on_rtp_error_ = srs_error_copy(err);
+    }
+};
+
 VOID TEST(AppTest2, AacRawAppendAdtsHeaderSequenceHeader)
 {
     srs_error_t err;
@@ -2174,6 +2281,948 @@ VOID TEST(AppTest2, RtcSourcePublishStreamWithConsumerDestroy)
     srs_freep(consumer2);
 }
 
+VOID TEST(AppTest2, RtcSourceConsumerDumpsBasicSuccess)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create a consumer
+    ISrsRtcConsumer *consumer = NULL;
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer));
+
+    // Test consumer_dumps with default parameters (all true)
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer));
+
+    // Verify the method returns success
+    // Note: The method only prints a trace message and returns srs_success
+}
+
+VOID TEST(AppTest2, RtcSourceConsumerDumpsWithAllParameterCombinations)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create a consumer
+    ISrsRtcConsumer *consumer = NULL;
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer));
+
+    // Test all combinations of ds, dm, dg parameters
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, true, true, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, true, true, false));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, true, false, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, true, false, false));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, false, true, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, false, true, false));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, false, false, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, false, false, false));
+}
+
+VOID TEST(AppTest2, RtcSourceConsumerDumpsWithNullConsumer)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Test consumer_dumps with NULL consumer - should still succeed
+    // The current implementation doesn't use the consumer parameter
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(NULL));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(NULL, true, true, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(NULL, false, false, false));
+}
+
+VOID TEST(AppTest2, RtcSourceConsumerDumpsMultipleConsumers)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create multiple consumers
+    ISrsRtcConsumer *consumer1 = NULL;
+    ISrsRtcConsumer *consumer2 = NULL;
+    ISrsRtcConsumer *consumer3 = NULL;
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer1));
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer2));
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer3));
+
+    // Test consumer_dumps with different consumers
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer1));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer2, true, false, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer3, false, true, false));
+
+    // Test multiple calls on same consumer
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer1));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer1, false, false, false));
+}
+
+VOID TEST(AppTest2, RtcSourceConsumerDumpsWithMockConsumer)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create a mock consumer (not created through source->create_consumer)
+    SrsUniquePtr<MockRtcConsumer> mock_consumer(new MockRtcConsumer());
+
+    // Test consumer_dumps with mock consumer - should still succeed
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(mock_consumer.get()));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(mock_consumer.get(), true, true, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(mock_consumer.get(), false, false, false));
+}
+
+VOID TEST(AppTest2, RtcSourceConsumerDumpsSequentialCalls)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create a consumer
+    ISrsRtcConsumer *consumer = NULL;
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer));
+
+    // Test multiple sequential calls to consumer_dumps
+    for (int i = 0; i < 10; i++) {
+        HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer));
+    }
+
+    // Test sequential calls with different parameter combinations
+    for (int i = 0; i < 5; i++) {
+        bool ds = (i % 2 == 0);
+        bool dm = (i % 3 == 0);
+        bool dg = (i % 4 == 0);
+        HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, ds, dm, dg));
+    }
+}
+
+VOID TEST(AppTest2, RtcSourceConsumerDumpsAfterSourceStateChanges)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create a consumer
+    ISrsRtcConsumer *consumer = NULL;
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer));
+
+    // Test consumer_dumps before publish
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer));
+
+    // Publish the source
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // Test consumer_dumps after publish
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, true, true, true));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, false, false, false));
+
+    // Unpublish the source
+    source->on_unpublish();
+
+    // Test consumer_dumps after unpublish
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer));
+    HELPER_EXPECT_SUCCESS(source->consumer_dumps(consumer, true, false, true));
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeSuccess)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create and set up stream description with audio and video tracks
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    stream_desc->id_ = "test-stream-with-bridge";
+
+    // Add audio track
+    stream_desc->audio_track_desc_ = new SrsRtcTrackDescription();
+    stream_desc->audio_track_desc_->type_ = "audio";
+    stream_desc->audio_track_desc_->id_ = "audio-track-1";
+    stream_desc->audio_track_desc_->ssrc_ = 12345;
+    stream_desc->audio_track_desc_->media_ = new SrsAudioPayload(111, "opus", 48000, 2);
+
+    // Add video track
+    SrsRtcTrackDescription *video_track = new SrsRtcTrackDescription();
+    video_track->type_ = "video";
+    video_track->id_ = "video-track-1";
+    video_track->ssrc_ = 67890;
+    video_track->media_ = new SrsVideoPayload(102, "H264", 90000);
+    stream_desc->video_track_descs_.push_back(video_track);
+
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with RTC bridge - should call all bridge methods
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // Verify bridge methods were called in correct order
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(1, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(1, mock_bridge->on_publish_count_);
+
+    // Verify bridge was initialized with correct request (bridge gets a copy)
+    EXPECT_TRUE(mock_bridge->last_initialize_req_ != NULL);
+
+    // Verify bridge was set up with correct codecs
+    EXPECT_EQ(SrsAudioCodecIdOpus, mock_bridge->last_audio_codec_);
+    EXPECT_EQ(SrsVideoCodecIdAVC, mock_bridge->last_video_codec_);
+
+    // Verify source state
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_TRUE(source->is_delivering_packets_);
+
+    // Clean up properly by calling on_unpublish to unsubscribe from timer
+    source->on_unpublish();
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeInitializeFailure)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge that fails on initialize (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    srs_error_t bridge_error = srs_error_new(ERROR_SYSTEM_ASSERT_FAILED, "bridge initialize failed");
+    mock_bridge->set_initialize_error(bridge_error);
+    srs_freep(bridge_error);
+
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with failing bridge - should return error
+    HELPER_EXPECT_FAILED(source->on_publish());
+
+    // Verify bridge initialize was called but setup_codec and on_publish were not
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(0, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(0, mock_bridge->on_publish_count_);
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeSetupCodecFailure)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description with audio and video tracks
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    stream_desc->audio_track_desc_ = new SrsRtcTrackDescription();
+    stream_desc->audio_track_desc_->type_ = "audio";
+    stream_desc->audio_track_desc_->media_ = new SrsAudioPayload(111, "opus", 48000, 2);
+
+    SrsRtcTrackDescription *video_track = new SrsRtcTrackDescription();
+    video_track->type_ = "video";
+    video_track->media_ = new SrsVideoPayload(102, "H264", 90000);
+    stream_desc->video_track_descs_.push_back(video_track);
+
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge that fails on setup_codec (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    srs_error_t bridge_error = srs_error_new(ERROR_SYSTEM_ASSERT_FAILED, "bridge setup codec failed");
+    mock_bridge->set_setup_codec_error(bridge_error);
+    srs_freep(bridge_error);
+
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with failing bridge - should return error
+    HELPER_EXPECT_FAILED(source->on_publish());
+
+    // Verify bridge initialize and setup_codec were called but on_publish was not
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(1, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(0, mock_bridge->on_publish_count_);
+
+    // Verify correct codecs were passed to setup_codec
+    EXPECT_EQ(SrsAudioCodecIdOpus, mock_bridge->last_audio_codec_);
+    EXPECT_EQ(SrsVideoCodecIdAVC, mock_bridge->last_video_codec_);
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeOnPublishFailure)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge that fails on on_publish (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    srs_error_t bridge_error = srs_error_new(ERROR_SYSTEM_ASSERT_FAILED, "bridge on_publish failed");
+    mock_bridge->set_on_publish_error(bridge_error);
+    srs_freep(bridge_error);
+
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with failing bridge - should return error
+    HELPER_EXPECT_FAILED(source->on_publish());
+
+    // Verify all bridge methods were called
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(1, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(1, mock_bridge->on_publish_count_);
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeDefaultCodecs)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description without audio/video tracks (should use defaults)
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with default codecs
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // Verify bridge methods were called
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(1, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(1, mock_bridge->on_publish_count_);
+
+    // Verify default codecs were used (Opus for audio, AVC/H264 for video)
+    EXPECT_EQ(SrsAudioCodecIdOpus, mock_bridge->last_audio_codec_);
+    EXPECT_EQ(SrsVideoCodecIdAVC, mock_bridge->last_video_codec_);
+
+    // Clean up properly by calling on_unpublish to unsubscribe from timer
+    source->on_unpublish();
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeAudioOnlyStream)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description with only audio track
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    stream_desc->audio_track_desc_ = new SrsRtcTrackDescription();
+    stream_desc->audio_track_desc_->type_ = "audio";
+    stream_desc->audio_track_desc_->media_ = new SrsAudioPayload(111, "opus", 48000, 2);
+    // No video tracks
+
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with audio-only stream
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // Verify bridge methods were called
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(1, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(1, mock_bridge->on_publish_count_);
+
+    // Verify codecs (Opus for audio, default AVC for video even in audio-only stream)
+    EXPECT_EQ(SrsAudioCodecIdOpus, mock_bridge->last_audio_codec_);
+    EXPECT_EQ(SrsVideoCodecIdAVC, mock_bridge->last_video_codec_);
+
+    // Clean up properly by calling on_unpublish to unsubscribe from timer
+    source->on_unpublish();
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeVideoOnlyStream)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description with only video track
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    // No audio track
+    SrsRtcTrackDescription *video_track = new SrsRtcTrackDescription();
+    video_track->type_ = "video";
+    video_track->media_ = new SrsVideoPayload(102, "H264", 90000);
+    stream_desc->video_track_descs_.push_back(video_track);
+
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with video-only stream
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // Verify bridge methods were called
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(1, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(1, mock_bridge->on_publish_count_);
+
+    // Verify codecs (default Opus for audio even in video-only stream, AVC/H264 for video)
+    EXPECT_EQ(SrsAudioCodecIdOpus, mock_bridge->last_audio_codec_);
+    EXPECT_EQ(SrsVideoCodecIdAVC, mock_bridge->last_video_codec_);
+
+    // Clean up properly by calling on_unpublish to unsubscribe from timer
+    source->on_unpublish();
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithoutRtcBridge)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    source->set_stream_desc(stream_desc.get());
+
+    // No RTC bridge set (rtc_bridge_ is NULL)
+    EXPECT_TRUE(source->rtc_bridge_ == NULL);
+
+    // Test on_publish without RTC bridge - should succeed
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // Verify source state
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_TRUE(source->is_delivering_packets_);
+}
+
+VOID TEST(AppTest2, RtcSourceOnPublishWithRtcBridgeTimerSubscription)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create stream description
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    source->set_stream_desc(stream_desc.get());
+
+    // Create mock RTC bridge (source will take ownership)
+    MockRtcBridge *mock_bridge = new MockRtcBridge();
+    source->set_bridge(mock_bridge);
+
+    // Test on_publish with RTC bridge - should subscribe to timer
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // Verify bridge methods were called
+    EXPECT_EQ(1, mock_bridge->initialize_count_);
+    EXPECT_EQ(1, mock_bridge->setup_codec_count_);
+    EXPECT_EQ(1, mock_bridge->on_publish_count_);
+
+    // Note: We can't easily test timer subscription without accessing private members
+    // or creating a more complex mock setup. The test verifies the method executes successfully.
+
+    // Verify source state
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_TRUE(source->is_delivering_packets_);
+
+    // Clean up properly by calling on_unpublish to unsubscribe from timer
+    source->on_unpublish();
+}
+
+VOID TEST(AppTest2, RtcSourceCanPublishInitialState)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Initially, stream is not created, so can_publish should return true
+    EXPECT_TRUE(source->can_publish());
+    EXPECT_FALSE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+}
+
+VOID TEST(AppTest2, RtcSourceCanPublishAfterStreamCreated)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Initially can publish
+    EXPECT_TRUE(source->can_publish());
+
+    // Set stream as created
+    source->set_stream_created();
+
+    // After stream is created, can_publish should return false
+    EXPECT_FALSE(source->can_publish());
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+}
+
+VOID TEST(AppTest2, RtcSourceCanPublishAfterPublish)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Initially can publish
+    EXPECT_TRUE(source->can_publish());
+
+    // Call on_publish which sets both is_created_ and is_delivering_packets_ to true
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+
+    // After publish, can_publish should return false because is_created_ is true
+    EXPECT_FALSE(source->can_publish());
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_TRUE(source->is_delivering_packets_);
+}
+
+VOID TEST(AppTest2, RtcSourceCanPublishAfterUnpublish)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Publish first
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+    EXPECT_FALSE(source->can_publish());
+
+    // Unpublish - this sets both is_created_ and is_delivering_packets_ to false
+    source->on_unpublish();
+
+    // After unpublish, can_publish should return true because is_created_ is now false
+    EXPECT_TRUE(source->can_publish());
+    EXPECT_FALSE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+}
+
+VOID TEST(AppTest2, RtcSourceSetStreamCreatedBasic)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Verify initial state
+    EXPECT_FALSE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+    EXPECT_TRUE(source->can_publish());
+
+    // Call set_stream_created
+    source->set_stream_created();
+
+    // Verify state after set_stream_created
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_); // Should remain false
+    EXPECT_FALSE(source->can_publish()); // Should now return false
+}
+
+VOID TEST(AppTest2, RtcSourceSetStreamCreatedMultipleCalls)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // First call to set_stream_created
+    source->set_stream_created();
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+
+    // Note: Multiple calls to set_stream_created would violate the assertion
+    // srs_assert(!is_created_ && !is_delivering_packets_) in the implementation
+    // So we don't test multiple calls as it would cause assertion failure
+}
+
+VOID TEST(AppTest2, RtcSourceSetStreamCreatedBeforePublish)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Set stream created first
+    source->set_stream_created();
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+    EXPECT_FALSE(source->can_publish());
+
+    // Then call on_publish - this should set is_delivering_packets_ to true
+    // but is_created_ is already true
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_TRUE(source->is_delivering_packets_);
+    EXPECT_FALSE(source->can_publish());
+}
+
+VOID TEST(AppTest2, RtcSourceSetStreamCreatedStateTransitions)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Test state transitions
+    // Initial state: not created, not delivering, can publish
+    EXPECT_FALSE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+    EXPECT_TRUE(source->can_publish());
+
+    // After set_stream_created: created, not delivering, cannot publish
+    source->set_stream_created();
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+    EXPECT_FALSE(source->can_publish());
+
+    // After on_publish: created, delivering, cannot publish
+    HELPER_EXPECT_SUCCESS(source->on_publish());
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_TRUE(source->is_delivering_packets_);
+    EXPECT_FALSE(source->can_publish());
+
+    // After on_unpublish: not created, not delivering, can publish
+    source->on_unpublish();
+    EXPECT_FALSE(source->is_created_);
+    EXPECT_FALSE(source->is_delivering_packets_);
+    EXPECT_TRUE(source->can_publish()); // Can publish again because is_created_ is now false
+}
+
+VOID TEST(AppTest2, RtcSourceCanPublishWithConsumers)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create consumers - should not affect can_publish
+    ISrsRtcConsumer *consumer1 = NULL;
+    ISrsRtcConsumer *consumer2 = NULL;
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer1));
+    HELPER_EXPECT_SUCCESS(source->create_consumer(consumer2));
+
+    // can_publish should still return true (only depends on is_created_)
+    EXPECT_TRUE(source->can_publish());
+
+    // Set stream created
+    source->set_stream_created();
+
+    // can_publish should now return false regardless of consumers
+    EXPECT_FALSE(source->can_publish());
+}
+
+VOID TEST(AppTest2, RtcSourceCanPublishWithStreamDescription)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create and set stream description - should not affect can_publish
+    SrsUniquePtr<SrsRtcSourceDescription> stream_desc(new SrsRtcSourceDescription());
+    stream_desc->id_ = "test-stream";
+    source->set_stream_desc(stream_desc.get());
+
+    // can_publish should still return true (only depends on is_created_)
+    EXPECT_TRUE(source->can_publish());
+
+    // Set stream created
+    source->set_stream_created();
+
+    // can_publish should now return false regardless of stream description
+    EXPECT_FALSE(source->can_publish());
+}
+
+VOID TEST(AppTest2, RtcSourceCanPublishConsistency)
+{
+    srs_error_t err;
+
+    // Create multiple sources to test consistency
+    for (int i = 0; i < 5; i++) {
+        SrsUniquePtr<SrsRequest> req(new SrsRequest());
+        req->host_ = "localhost";
+        req->vhost_ = "test.vhost";
+        req->app_ = "live";
+        req->stream_ = "test" + std::to_string(i);
+
+        SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+        HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+        // All sources should initially allow publishing
+        EXPECT_TRUE(source->can_publish());
+
+        // After setting stream created, none should allow publishing
+        source->set_stream_created();
+        EXPECT_FALSE(source->can_publish());
+
+        // Multiple calls to can_publish should return consistent results
+        for (int j = 0; j < 3; j++) {
+            EXPECT_FALSE(source->can_publish());
+        }
+    }
+}
+
+VOID TEST(AppTest2, RtcSourceSetStreamCreatedWithEventHandlers)
+{
+    srs_error_t err;
+
+    // Create a mock request
+    SrsUniquePtr<SrsRequest> req(new SrsRequest());
+    req->host_ = "localhost";
+    req->vhost_ = "test.vhost";
+    req->app_ = "live";
+    req->stream_ = "test";
+
+    // Create RTC source and initialize
+    SrsUniquePtr<SrsRtcSource> source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(source->initialize(req.get()));
+
+    // Create and subscribe event handlers
+    SrsUniquePtr<MockRtcSourceEventHandler> handler1(new MockRtcSourceEventHandler());
+    SrsUniquePtr<MockRtcSourceEventHandler> handler2(new MockRtcSourceEventHandler());
+    source->subscribe(handler1.get());
+    source->subscribe(handler2.get());
+
+    // Verify initial state
+    EXPECT_FALSE(source->is_created_);
+    EXPECT_TRUE(source->can_publish());
+
+    // Call set_stream_created - should not trigger event handlers
+    source->set_stream_created();
+
+    // Verify state changed but handlers not called
+    EXPECT_TRUE(source->is_created_);
+    EXPECT_FALSE(source->can_publish());
+    EXPECT_EQ(0, handler1->on_unpublish_count_);
+    EXPECT_EQ(0, handler1->on_consumers_finished_count_);
+    EXPECT_EQ(0, handler2->on_unpublish_count_);
+    EXPECT_EQ(0, handler2->on_consumers_finished_count_);
+}
+
 VOID TEST(AppTest2, RtcSourcePublishStreamWithoutConsumerDestroy)
 {
     srs_error_t err;
diff --git a/trunk/src/utest/srs_utest_app3.cpp b/trunk/src/utest/srs_utest_app3.cpp
new file mode 100644
index 000000000..4d8227a31
--- /dev/null
+++ b/trunk/src/utest/srs_utest_app3.cpp
@@ -0,0 +1,1281 @@
+//
+// Copyright (c) 2013-2025 The SRS Authors
+//
+// SPDX-License-Identifier: MIT
+//
+
+#include <srs_utest_app3.hpp>
+
+using namespace std;
+
+#include <srs_app_stream_bridge.hpp>
+#include <srs_app_rtc_source.hpp>
+#include <srs_app_rtmp_source.hpp>
+#include <srs_app_srt_source.hpp>
+#include <srs_core_autofree.hpp>
+#include <srs_kernel_error.hpp>
+#include <srs_kernel_rtc_rtp.hpp>
+#include <srs_protocol_format.hpp>
+#include <srs_protocol_rtmp_stack.hpp>
+#ifdef SRS_RTSP
+#include <srs_app_rtsp_source.hpp>
+#endif
+
+// Mock request class for testing stream bridges
+class MockStreamBridgeRequest : public ISrsRequest
+{
+public:
+    MockStreamBridgeRequest(string vhost = "__defaultVhost__", string app = "live", string stream = "test")
+    {
+        vhost_ = vhost;
+        app_ = app;
+        stream_ = stream;
+        host_ = "127.0.0.1";
+        port_ = 1935;
+        tcUrl_ = "rtmp://127.0.0.1/" + app;
+        schema_ = "rtmp";
+        param_ = "";
+        duration_ = 0;
+        args_ = NULL;
+        protocol_ = "rtmp";
+        objectEncoding_ = 0;
+    }
+
+    virtual ~MockStreamBridgeRequest() {}
+
+    virtual ISrsRequest *copy()
+    {
+        MockStreamBridgeRequest *req = new MockStreamBridgeRequest(vhost_, app_, stream_);
+        req->tcUrl_ = tcUrl_;
+        req->pageUrl_ = pageUrl_;
+        req->swfUrl_ = swfUrl_;
+        req->objectEncoding_ = objectEncoding_;
+        req->schema_ = schema_;
+        req->param_ = param_;
+        req->ice_ufrag_ = ice_ufrag_;
+        req->ice_pwd_ = ice_pwd_;
+        req->duration_ = duration_;
+        req->protocol_ = protocol_;
+        req->ip_ = ip_;
+        return req;
+    }
+
+    virtual string get_stream_url()
+    {
+        if (vhost_ == "__defaultVhost__" || vhost_.empty()) {
+            return "/" + app_ + "/" + stream_;
+        } else {
+            return vhost_ + "/" + app_ + "/" + stream_;
+        }
+    }
+
+    virtual void update_auth(ISrsRequest *req) {}
+    virtual void strip() {}
+    virtual ISrsRequest *as_http() { return this; }
+};
+
+// Mock frame target for testing bridges
+class MockFrameTarget : public ISrsFrameTarget
+{
+public:
+    int on_frame_count_;
+    SrsMediaPacket *last_frame_;
+    srs_error_t frame_error_;
+
+    MockFrameTarget()
+    {
+        on_frame_count_ = 0;
+        last_frame_ = NULL;
+        frame_error_ = srs_success;
+    }
+
+    virtual ~MockFrameTarget()
+    {
+        srs_freep(frame_error_);
+    }
+
+    virtual srs_error_t on_frame(SrsMediaPacket *frame)
+    {
+        on_frame_count_++;
+        last_frame_ = frame;
+        return srs_error_copy(frame_error_);
+    }
+
+    void set_frame_error(srs_error_t err)
+    {
+        srs_freep(frame_error_);
+        frame_error_ = srs_error_copy(err);
+    }
+};
+
+// Mock RTP target for testing bridges
+class MockRtpTarget : public ISrsRtpTarget
+{
+public:
+    int on_rtp_count_;
+    SrsRtpPacket *last_rtp_;
+    srs_error_t rtp_error_;
+
+    MockRtpTarget()
+    {
+        on_rtp_count_ = 0;
+        last_rtp_ = NULL;
+        rtp_error_ = srs_success;
+    }
+
+    virtual ~MockRtpTarget()
+    {
+        srs_freep(rtp_error_);
+    }
+
+    virtual srs_error_t on_rtp(SrsRtpPacket *pkt)
+    {
+        on_rtp_count_++;
+        last_rtp_ = pkt;
+        return srs_error_copy(rtp_error_);
+    }
+
+    void set_rtp_error(srs_error_t err)
+    {
+        srs_freep(rtp_error_);
+        rtp_error_ = srs_error_copy(err);
+    }
+};
+
+// Mock SRT target for testing bridges
+class MockSrtTarget : public ISrsSrtTarget
+{
+public:
+    int on_packet_count_;
+    SrsSrtPacket *last_packet_;
+    srs_error_t packet_error_;
+
+    MockSrtTarget()
+    {
+        on_packet_count_ = 0;
+        last_packet_ = NULL;
+        packet_error_ = srs_success;
+    }
+
+    virtual ~MockSrtTarget()
+    {
+        srs_freep(packet_error_);
+    }
+
+    virtual srs_error_t on_packet(SrsSrtPacket *pkt)
+    {
+        on_packet_count_++;
+        last_packet_ = pkt;
+        return srs_error_copy(packet_error_);
+    }
+
+    void set_packet_error(srs_error_t err)
+    {
+        srs_freep(packet_error_);
+        packet_error_ = srs_error_copy(err);
+    }
+};
+
+// Mock live source handler for testing
+class MockLiveSourceHandler : public ISrsLiveSourceHandler
+{
+public:
+    int on_publish_count_;
+    int on_unpublish_count_;
+
+    MockLiveSourceHandler()
+    {
+        on_publish_count_ = 0;
+        on_unpublish_count_ = 0;
+    }
+
+    virtual ~MockLiveSourceHandler() {}
+
+    virtual srs_error_t on_publish(ISrsRequest* r)
+    {
+        on_publish_count_++;
+        return srs_success;
+    }
+
+    virtual void on_unpublish(ISrsRequest* r)
+    {
+        on_unpublish_count_++;
+    }
+};
+
+// Test ISrsFrameTarget interface
+VOID TEST(StreamBridgeTest, ISrsFrameTarget_Interface)
+{
+    MockFrameTarget target;
+
+    // Test initial state
+    EXPECT_EQ(0, target.on_frame_count_);
+    EXPECT_TRUE(target.last_frame_ == NULL);
+
+    // Create a mock frame
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+
+    // Test on_frame call
+    srs_error_t err = target.on_frame(frame.get());
+    EXPECT_TRUE(err == srs_success);
+    EXPECT_EQ(1, target.on_frame_count_);
+    EXPECT_EQ(frame.get(), target.last_frame_);
+}
+
+// Test ISrsRtpTarget interface
+VOID TEST(StreamBridgeTest, ISrsRtpTarget_Interface)
+{
+    MockRtpTarget target;
+    
+    // Test initial state
+    EXPECT_EQ(0, target.on_rtp_count_);
+    EXPECT_TRUE(target.last_rtp_ == NULL);
+    
+    // Create a mock RTP packet
+    SrsUniquePtr<SrsRtpPacket> pkt(new SrsRtpPacket());
+    pkt->header_.set_ssrc(12345);
+    
+    // Test on_rtp call
+    srs_error_t err = target.on_rtp(pkt.get());
+    EXPECT_TRUE(err == srs_success);
+    EXPECT_EQ(1, target.on_rtp_count_);
+    EXPECT_EQ(pkt.get(), target.last_rtp_);
+}
+
+// Test ISrsSrtTarget interface
+VOID TEST(StreamBridgeTest, ISrsSrtTarget_Interface)
+{
+    MockSrtTarget target;
+
+    // Test initial state
+    EXPECT_EQ(0, target.on_packet_count_);
+    EXPECT_TRUE(target.last_packet_ == NULL);
+
+    // Create a mock SRT packet
+    SrsUniquePtr<SrsSrtPacket> pkt(new SrsSrtPacket());
+    char *data = pkt->wrap(188); // TS packet size
+    data[0] = 0x47; // TS sync byte
+
+    // Test on_packet call
+    srs_error_t err = target.on_packet(pkt.get());
+    EXPECT_TRUE(err == srs_success);
+    EXPECT_EQ(1, target.on_packet_count_);
+    EXPECT_EQ(pkt.get(), target.last_packet_);
+}
+
+// Test SrsRtmpBridge basic functionality
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_BasicFunctionality)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+
+    // Test initial state - bridge should be empty
+    EXPECT_TRUE(bridge->empty());
+
+    // Test initialize with mock request
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Bridge should still be empty without targets
+    EXPECT_TRUE(bridge->empty());
+}
+
+// Test SrsRtmpBridge with RTC target
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_WithRtcTarget)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create and enable RTC target first
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source);
+
+    // Bridge should no longer be empty
+    EXPECT_FALSE(bridge->empty());
+
+    // Initialize bridge after setting target (this creates the rtp_builder_)
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test publish
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test unpublish
+    bridge->on_unpublish();
+}
+
+#ifdef SRS_RTSP
+// Test SrsRtmpBridge with RTSP target
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_WithRtspTarget)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create and enable RTSP target first
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    // Bridge should no longer be empty
+    EXPECT_FALSE(bridge->empty());
+
+    // Initialize bridge after setting target (this creates the rtsp_builder_)
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test publish
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test unpublish
+    bridge->on_unpublish();
+}
+
+// Test SrsRtmpBridge with both RTC and RTSP targets
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_WithRtcAndRtspTargets)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create and enable both RTC and RTSP targets
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source);
+
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    // Bridge should not be empty with both targets
+    EXPECT_FALSE(bridge->empty());
+
+    // Initialize bridge after setting targets
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test publish with both targets
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Create and send a frame to both targets
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    // Test unpublish
+    bridge->on_unpublish();
+}
+
+// Test SrsRtmpBridge RTSP target replacement
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_RtspTargetReplacement)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Set first RTSP target
+    SrsSharedPtr<SrsRtspSource> rtsp_source1(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source1->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source1);
+    EXPECT_FALSE(bridge->empty());
+
+    // Replace with second RTSP target
+    SrsSharedPtr<SrsRtspSource> rtsp_source2(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source2->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source2);
+    EXPECT_FALSE(bridge->empty());
+
+    // Re-initialize bridge after setting target
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test publish with new target
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+    bridge->on_unpublish();
+}
+#endif
+
+// Test SrsRtmpBridge frame handling - comprehensive coverage of on_frame() method
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_FrameHandling)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Create a mock media frame
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+
+    // Test frame handling without targets (should succeed)
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    // Enable RTC target and test again
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source);
+
+    // Re-initialize bridge after setting target (this creates the rtp_builder_)
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+}
+
+// Test SrsRtmpBridge on_frame() method with RTP builder path
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_OnFrameRtpBuilder)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Test frame handling without any targets first
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+#ifdef SRS_FFMPEG_FIT
+    // Enable RTC target to create RTP builder
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source);
+
+    // Re-initialize to create rtp_builder_
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test different frame types
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    bridge->on_unpublish();
+#endif
+}
+
+#ifdef SRS_RTSP
+// Test SrsRtmpBridge on_frame() method with RTSP builder path
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_OnFrameRtspBuilder)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test frame handling without RTSP target first
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    // Enable RTSP target to create RTSP builder
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    // Re-initialize to create rtsp_builder_
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test different frame types with RTSP builder
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    bridge->on_unpublish();
+}
+
+// Test SrsRtmpBridge on_frame() with both RTP and RTSP builders
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_OnFrameBothBuilders)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Enable both RTC and RTSP targets
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source);
+
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    // Initialize to create both builders
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test frame handling with both builders active
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    bridge->on_unpublish();
+}
+#endif
+
+// Test SrsSrtBridge basic functionality
+VOID TEST(StreamBridgeTest, SrsSrtBridge_BasicFunctionality)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+
+    // Test initial state - bridge should be empty
+    EXPECT_TRUE(bridge->empty());
+
+    // Test initialize with mock request
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Bridge should still be empty without targets
+    EXPECT_TRUE(bridge->empty());
+}
+
+// Test SrsSrtBridge with RTMP target
+VOID TEST(StreamBridgeTest, SrsSrtBridge_WithRtmpTarget)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    EXPECT_TRUE(bridge->empty());
+
+    // Create and enable RTMP target
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+
+    bridge->enable_srt2rtmp(rtmp_source);
+
+    // Bridge should no longer be empty
+    EXPECT_FALSE(bridge->empty());
+
+    // Test publish
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test unpublish
+    bridge->on_unpublish();
+}
+
+// Test SrsSrtBridge with RTC target
+VOID TEST(StreamBridgeTest, SrsSrtBridge_WithRtcTarget)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create and enable RTC target first
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_srt2rtc(rtc_source);
+
+    // Bridge should no longer be empty
+    EXPECT_FALSE(bridge->empty());
+
+    // Initialize bridge after setting target (this creates the rtp_builder_)
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test publish
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test unpublish
+    bridge->on_unpublish();
+}
+
+// Test SrsSrtBridge packet handling
+VOID TEST(StreamBridgeTest, SrsSrtBridge_PacketHandling)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Create a mock SRT packet with TS data
+    SrsUniquePtr<SrsSrtPacket> pkt(new SrsSrtPacket());
+    char *data = pkt->wrap(188); // Standard TS packet size
+    memset(data, 0, 188);
+    // Set TS sync byte
+    data[0] = 0x47;
+
+    // Test packet handling (should succeed even without targets)
+    HELPER_EXPECT_SUCCESS(bridge->on_packet(pkt.get()));
+}
+
+// Test SrsSrtBridge frame handling - comprehensive coverage of on_frame() method
+VOID TEST(StreamBridgeTest, SrsSrtBridge_FrameHandling)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Create a mock media frame
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+
+    // Test frame handling without targets (should succeed)
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    // Note: Skip testing with RTMP target to avoid complex source initialization
+    // The basic frame handling functionality is already tested above
+}
+
+// Test SrsSrtBridge on_frame() method with RTMP target path
+VOID TEST(StreamBridgeTest, SrsSrtBridge_OnFrameRtmpTarget)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test frame handling without RTMP target first
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    // Enable RTMP target
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+    bridge->enable_srt2rtmp(rtmp_source);
+
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test different frame types with RTMP target
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    bridge->on_unpublish();
+}
+
+#ifdef SRS_FFMPEG_FIT
+// Test SrsSrtBridge on_frame() method with RTP builder path
+VOID TEST(StreamBridgeTest, SrsSrtBridge_OnFrameRtpBuilder)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test frame handling without RTC target first
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    // Enable RTC target to create RTP builder
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_srt2rtc(rtc_source);
+
+    // Re-initialize to create rtp_builder_
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test different frame types with RTP builder
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    bridge->on_unpublish();
+}
+
+// Test SrsSrtBridge on_frame() with both RTMP target and RTP builder
+VOID TEST(StreamBridgeTest, SrsSrtBridge_OnFrameBothTargets)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Enable both RTMP and RTC targets
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+    bridge->enable_srt2rtmp(rtmp_source);
+
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_srt2rtc(rtc_source);
+
+    // Initialize to create rtp_builder_
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test frame handling with both targets active
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    bridge->on_unpublish();
+}
+#endif
+
+// Test SrsRtcBridge basic functionality
+VOID TEST(StreamBridgeTest, SrsRtcBridge_BasicFunctionality)
+{
+    SrsUniquePtr<SrsRtcBridge> bridge(new SrsRtcBridge());
+
+    // Test initial state - bridge should be empty
+    EXPECT_TRUE(bridge->empty());
+
+    // Note: SrsRtcBridge requires an RTMP target to be set before initialization
+    // This is tested in the SrsRtcBridge_WithRtmpTarget test
+}
+
+// Test SrsRtcBridge with RTMP target
+VOID TEST(StreamBridgeTest, SrsRtcBridge_WithRtmpTarget)
+{
+    SrsUniquePtr<SrsRtcBridge> bridge(new SrsRtcBridge());
+
+    // Create a mock RTMP target using shared pointer
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    bridge->enable_rtc2rtmp(rtmp_source);
+
+    // Bridge should not be empty with target
+    EXPECT_FALSE(bridge->empty());
+
+    // Note: Full initialization and testing requires complex source setup
+    // The basic target assignment functionality is tested above
+}
+
+// Test SrsRtcBridge RTP packet handling
+VOID TEST(StreamBridgeTest, SrsRtcBridge_RtpPacketHandling)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtcBridge> bridge(new SrsRtcBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create RTMP target for the bridge
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+    bridge->enable_rtc2rtmp(rtmp_source);
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->setup_codec(SrsAudioCodecIdAAC, SrsVideoCodecIdAVC));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test RTP packet handling - the frame builder checks for payload and returns early if NULL
+    // This is the expected behavior, so we test that it handles NULL payload gracefully
+    SrsUniquePtr<SrsRtpPacket> rtp_packet(new SrsRtpPacket());
+
+    // Set up basic RTP header (payload will be NULL, which is handled gracefully)
+    rtp_packet->header_.set_sequence(100);
+    rtp_packet->header_.set_timestamp(1000);
+    rtp_packet->header_.set_ssrc(0x12345678);
+    rtp_packet->header_.set_payload_type(96);
+    rtp_packet->frame_type_ = SrsFrameTypeVideo;
+
+    // Test with RTP packet without payload (should succeed - frame builder returns early)
+    HELPER_EXPECT_SUCCESS(bridge->on_rtp(rtp_packet.get()));
+
+    bridge->on_unpublish();
+}
+
+// Test SrsRtcBridge RTP packet processing with different packet types
+VOID TEST(StreamBridgeTest, SrsRtcBridge_RtpPacketTypes)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtcBridge> bridge(new SrsRtcBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create RTMP target for the bridge
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+    bridge->enable_rtc2rtmp(rtmp_source);
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->setup_codec(SrsAudioCodecIdAAC, SrsVideoCodecIdAVC));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test different RTP packet scenarios - all without payload (handled gracefully)
+    for (int i = 0; i < 5; ++i) {
+        SrsUniquePtr<SrsRtpPacket> rtp_packet(new SrsRtpPacket());
+
+        // Simulate different packet types by varying sequence numbers and timestamps
+        rtp_packet->header_.set_sequence(i);
+        rtp_packet->header_.set_timestamp(i * 1000);
+        rtp_packet->header_.set_ssrc(0x87654321);
+        rtp_packet->header_.set_payload_type(97);
+        rtp_packet->frame_type_ = (i % 2 == 0) ? SrsFrameTypeVideo : SrsFrameTypeAudio;
+
+        // Test without payload - frame builder handles this gracefully
+        HELPER_EXPECT_SUCCESS(bridge->on_rtp(rtp_packet.get()));
+    }
+
+    bridge->on_unpublish();
+}
+
+// Test SrsRtcBridge RTP packet handling without frame builder
+VOID TEST(StreamBridgeTest, SrsRtcBridge_RtpWithoutFrameBuilder)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtcBridge> bridge(new SrsRtcBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Test RTP handling without proper initialization (no frame builder)
+    SrsUniquePtr<SrsRtpPacket> rtp_packet(new SrsRtpPacket());
+
+    // Should succeed even without frame builder (graceful handling)
+    HELPER_EXPECT_SUCCESS(bridge->on_rtp(rtp_packet.get()));
+}
+
+// Test SrsRtcBridge RTP packet handling lifecycle
+VOID TEST(StreamBridgeTest, SrsRtcBridge_RtpLifecycle)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtcBridge> bridge(new SrsRtcBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create RTMP target
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+    bridge->enable_rtc2rtmp(rtmp_source);
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->setup_codec(SrsAudioCodecIdAAC, SrsVideoCodecIdAVC));
+
+    // Test RTP handling before publish
+    SrsUniquePtr<SrsRtpPacket> rtp_packet1(new SrsRtpPacket());
+    HELPER_EXPECT_SUCCESS(bridge->on_rtp(rtp_packet1.get()));
+
+    // Test RTP handling after publish
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+    SrsUniquePtr<SrsRtpPacket> rtp_packet2(new SrsRtpPacket());
+    HELPER_EXPECT_SUCCESS(bridge->on_rtp(rtp_packet2.get()));
+
+    // Test RTP handling after unpublish
+    bridge->on_unpublish();
+    SrsUniquePtr<SrsRtpPacket> rtp_packet3(new SrsRtpPacket());
+    HELPER_EXPECT_SUCCESS(bridge->on_rtp(rtp_packet3.get()));
+}
+
+// Test bridge error handling
+VOID TEST(StreamBridgeTest, Bridge_ErrorHandling)
+{
+    srs_error_t err;
+
+    // Test SrsRtmpBridge with invalid frame
+    SrsUniquePtr<SrsRtmpBridge> rtmp_bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    HELPER_EXPECT_SUCCESS(rtmp_bridge->initialize(req.get()));
+
+    // Test with NULL frame (should handle gracefully)
+    HELPER_EXPECT_SUCCESS(rtmp_bridge->on_frame(NULL));
+
+    // Test SrsSrtBridge with invalid packet
+    SrsUniquePtr<SrsSrtBridge> srt_bridge(new SrsSrtBridge());
+    HELPER_EXPECT_SUCCESS(srt_bridge->initialize(req.get()));
+
+    // Note: Skip NULL packet test as it causes segmentation fault
+    // The bridge expects valid packet objects
+}
+
+// Test bridge lifecycle management
+VOID TEST(StreamBridgeTest, Bridge_LifecycleManagement)
+{
+    srs_error_t err;
+
+    // Test multiple initialize calls
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // First initialize
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Second initialize (should work)
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test multiple publish/unpublish cycles
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source);
+
+    // Re-initialize bridge after setting target
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // First cycle
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+    bridge->on_unpublish();
+
+    // Second cycle
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+    bridge->on_unpublish();
+}
+
+// Test bridge with multiple targets
+VOID TEST(StreamBridgeTest, SrsSrtBridge_MultipleTargets)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    EXPECT_TRUE(bridge->empty());
+
+    // Enable both RTMP and RTC targets
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+    bridge->enable_srt2rtmp(rtmp_source);
+
+    SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+    bridge->enable_srt2rtc(rtc_source);
+
+    // Bridge should not be empty
+    EXPECT_FALSE(bridge->empty());
+
+    // Re-initialize bridge after setting targets (this creates the rtp_builder_)
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test publish with multiple targets
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Create and send a frame
+    SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+    frame->message_type_ = SrsFrameTypeVideo;
+
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+    // Test unpublish
+    bridge->on_unpublish();
+}
+
+// Test bridge target replacement
+VOID TEST(StreamBridgeTest, Bridge_TargetReplacement)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Initialize bridge
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Set first RTC target
+    SrsSharedPtr<SrsRtcSource> rtc_source1(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source1->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source1);
+    EXPECT_FALSE(bridge->empty());
+
+    // Replace with second RTC target
+    SrsSharedPtr<SrsRtcSource> rtc_source2(new SrsRtcSource());
+    HELPER_EXPECT_SUCCESS(rtc_source2->initialize(req.get()));
+    bridge->enable_rtmp2rtc(rtc_source2);
+    EXPECT_FALSE(bridge->empty());
+
+    // Re-initialize bridge after setting target
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test publish with new target
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+    bridge->on_unpublish();
+}
+
+// Test bridge state consistency
+VOID TEST(StreamBridgeTest, Bridge_StateConsistency)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Test empty state consistency
+    EXPECT_TRUE(bridge->empty());
+
+    // Initialize should not change empty state
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    EXPECT_TRUE(bridge->empty());
+
+    // Adding target should change empty state
+    SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+    HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+    bridge->enable_srt2rtmp(rtmp_source);
+    EXPECT_FALSE(bridge->empty());
+
+    // Removing target by setting NULL should make it empty again
+    bridge->enable_srt2rtmp(NULL);
+    EXPECT_TRUE(bridge->empty());
+}
+
+// Test bridge memory management
+VOID TEST(StreamBridgeTest, Bridge_MemoryManagement)
+{
+    srs_error_t err;
+
+    // Test that bridges properly manage their internal components
+    {
+        SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+        SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+        HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+        SrsSharedPtr<SrsRtcSource> rtc_source(new SrsRtcSource());
+        HELPER_EXPECT_SUCCESS(rtc_source->initialize(req.get()));
+        bridge->enable_rtmp2rtc(rtc_source);
+
+        // Re-initialize bridge after setting target
+        HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+        HELPER_EXPECT_SUCCESS(bridge->on_publish());
+        bridge->on_unpublish();
+
+        // Bridge destructor should clean up properly
+    }
+
+    {
+        SrsUniquePtr<SrsSrtBridge> bridge(new SrsSrtBridge());
+        SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+        HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+        SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+        HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+        bridge->enable_srt2rtmp(rtmp_source);
+
+        HELPER_EXPECT_SUCCESS(bridge->on_publish());
+        bridge->on_unpublish();
+
+        // Bridge destructor should clean up properly
+    }
+
+    {
+        SrsUniquePtr<SrsRtcBridge> bridge(new SrsRtcBridge());
+        SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+        SrsSharedPtr<SrsLiveSource> rtmp_source(new SrsLiveSource());
+        HELPER_EXPECT_SUCCESS(rtmp_source->initialize(rtmp_source, req.get()));
+        bridge->enable_rtc2rtmp(rtmp_source);
+
+        HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+        HELPER_EXPECT_SUCCESS(bridge->setup_codec(SrsAudioCodecIdAAC, SrsVideoCodecIdAVC));
+        HELPER_EXPECT_SUCCESS(bridge->on_publish());
+        bridge->on_unpublish();
+
+        // Bridge destructor should clean up properly
+    }
+}
+
+#ifdef SRS_RTSP
+// Test RTSP frame handling with different frame types
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_RtspFrameHandling)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create and enable RTSP target
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test video frame
+    SrsUniquePtr<SrsMediaPacket> video_frame(new SrsMediaPacket());
+    video_frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(video_frame.get()));
+
+    // Test audio frame
+    SrsUniquePtr<SrsMediaPacket> audio_frame(new SrsMediaPacket());
+    audio_frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(audio_frame.get()));
+
+    bridge->on_unpublish();
+}
+
+// Test RTSP bridge lifecycle management
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_RtspLifecycle)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Test lifecycle without target
+    EXPECT_TRUE(bridge->empty());
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Add RTSP target
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+    EXPECT_FALSE(bridge->empty());
+
+    // Re-initialize with target
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+
+    // Test multiple publish/unpublish cycles
+    for (int i = 0; i < 3; ++i) {
+        HELPER_EXPECT_SUCCESS(bridge->on_publish());
+        bridge->on_unpublish();
+    }
+}
+
+// Test RTSP error handling scenarios
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_RtspErrorHandling)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create RTSP target
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Note: Skip NULL frame test as it causes segmentation fault in RTSP builder
+    // The RTSP builder expects valid frame objects
+
+    bridge->on_unpublish();
+}
+
+// Test RTSP memory management
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_RtspMemoryManagement)
+{
+    srs_error_t err;
+
+    // Test multiple RTSP bridge creation and destruction
+    for (int i = 0; i < 5; ++i) {
+        SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+        SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+        SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+        HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+        bridge->enable_rtmp2rtsp(rtsp_source);
+
+        HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+        HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+        // Process some frames
+        SrsUniquePtr<SrsMediaPacket> frame(new SrsMediaPacket());
+        frame->message_type_ = SrsFrameTypeVideo;
+        HELPER_EXPECT_SUCCESS(bridge->on_frame(frame.get()));
+
+        bridge->on_unpublish();
+        // Bridge and source are automatically destroyed when going out of scope
+    }
+}
+
+// Test RTMP to RTSP protocol conversion
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_RtmpToRtspConversion)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create RTSP target for protocol conversion
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Simulate RTMP frames being converted to RTSP
+    // Test H.264 video frame
+    SrsUniquePtr<SrsMediaPacket> h264_frame(new SrsMediaPacket());
+    h264_frame->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(h264_frame.get()));
+
+    // Test AAC audio frame
+    SrsUniquePtr<SrsMediaPacket> aac_frame(new SrsMediaPacket());
+    aac_frame->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(aac_frame.get()));
+
+    // Test sequence header frames
+    SrsUniquePtr<SrsMediaPacket> seq_header(new SrsMediaPacket());
+    seq_header->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(seq_header.get()));
+
+    bridge->on_unpublish();
+}
+
+// Test RTSP bridge with codec changes
+VOID TEST(StreamBridgeTest, SrsRtmpBridge_RtspCodecChanges)
+{
+    srs_error_t err;
+
+    SrsUniquePtr<SrsRtmpBridge> bridge(new SrsRtmpBridge());
+    SrsUniquePtr<MockStreamBridgeRequest> req(new MockStreamBridgeRequest());
+
+    // Create RTSP target
+    SrsSharedPtr<SrsRtspSource> rtsp_source(new SrsRtspSource());
+    HELPER_EXPECT_SUCCESS(rtsp_source->initialize(req.get()));
+    bridge->enable_rtmp2rtsp(rtsp_source);
+
+    HELPER_EXPECT_SUCCESS(bridge->initialize(req.get()));
+    HELPER_EXPECT_SUCCESS(bridge->on_publish());
+
+    // Test different codec scenarios
+    // Video codec change simulation
+    SrsUniquePtr<SrsMediaPacket> video_frame1(new SrsMediaPacket());
+    video_frame1->message_type_ = SrsFrameTypeVideo;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(video_frame1.get()));
+
+    // Audio codec change simulation
+    SrsUniquePtr<SrsMediaPacket> audio_frame1(new SrsMediaPacket());
+    audio_frame1->message_type_ = SrsFrameTypeAudio;
+    HELPER_EXPECT_SUCCESS(bridge->on_frame(audio_frame1.get()));
+
+    bridge->on_unpublish();
+}
+#endif
diff --git a/trunk/src/utest/srs_utest_app3.hpp b/trunk/src/utest/srs_utest_app3.hpp
new file mode 100644
index 000000000..5032be626
--- /dev/null
+++ b/trunk/src/utest/srs_utest_app3.hpp
@@ -0,0 +1,15 @@
+//
+// Copyright (c) 2013-2025 The SRS Authors
+//
+// SPDX-License-Identifier: MIT
+//
+
+#ifndef SRS_UTEST_APP3_HPP
+#define SRS_UTEST_APP3_HPP
+
+/*
+#include <srs_utest_app3.hpp>
+*/
+#include <srs_utest.hpp>
+
+#endif