Delete media transport integration.
MediaTransport is deprecated and the code is unused.
No-Try: True
Bug: webrtc:9719
Change-Id: I5b864c1e74bf04df16c15f51b8fac3d407331dcd
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/160620
Commit-Queue: Bjorn Mellem <mellem@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Gustaf Ullberg <gustaf@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29923}
diff --git a/video/encoder_rtcp_feedback.cc b/video/encoder_rtcp_feedback.cc
index 19a8f64..a736d83 100644
--- a/video/encoder_rtcp_feedback.cc
+++ b/video/encoder_rtcp_feedback.cc
@@ -67,16 +67,6 @@
video_stream_encoder_->SendKeyFrame();
}
-void EncoderRtcpFeedback::OnKeyFrameRequested(uint64_t channel_id) {
- if (channel_id != ssrcs_[0]) {
- RTC_LOG(LS_INFO) << "Key frame request on unknown channel id " << channel_id
- << " expected " << ssrcs_[0];
- return;
- }
-
- video_stream_encoder_->SendKeyFrame();
-}
-
void EncoderRtcpFeedback::OnReceivedLossNotification(
uint32_t ssrc,
uint16_t seq_num_of_last_decodable,
diff --git a/video/encoder_rtcp_feedback.h b/video/encoder_rtcp_feedback.h
index 21624db..b5dd028 100644
--- a/video/encoder_rtcp_feedback.h
+++ b/video/encoder_rtcp_feedback.h
@@ -12,7 +12,6 @@
#include <vector>
-#include "api/transport/media/media_transport_interface.h"
#include "api/video/video_stream_encoder_interface.h"
#include "call/rtp_video_sender_interface.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ -24,12 +23,9 @@
class VideoStreamEncoderInterface;
// This class passes feedback (such as key frame requests or loss notifications)
-// from either Mediatransport or the RtpRtcp module.
-// TODO(bugs.webrtc.org/9719): Should be eliminated when RtpMediaTransport is
-// implemented.
+// from the RtpRtcp module.
class EncoderRtcpFeedback : public RtcpIntraFrameObserver,
- public RtcpLossNotificationObserver,
- public MediaTransportKeyFrameRequestCallback {
+ public RtcpLossNotificationObserver {
public:
EncoderRtcpFeedback(Clock* clock,
const std::vector<uint32_t>& ssrcs,
@@ -40,9 +36,6 @@
void OnReceivedIntraFrameRequest(uint32_t ssrc) override;
- // Implements MediaTransportKeyFrameRequestCallback
- void OnKeyFrameRequested(uint64_t channel_id) override;
-
// Implements RtcpLossNotificationObserver.
void OnReceivedLossNotification(uint32_t ssrc,
uint16_t seq_num_of_last_decodable,
diff --git a/video/encoder_rtcp_feedback_unittest.cc b/video/encoder_rtcp_feedback_unittest.cc
index b49a0b9..81ac22b 100644
--- a/video/encoder_rtcp_feedback_unittest.cc
+++ b/video/encoder_rtcp_feedback_unittest.cc
@@ -55,9 +55,4 @@
encoder_rtcp_feedback_.OnReceivedIntraFrameRequest(kSsrc);
}
-TEST_F(VieKeyRequestTest, TriggerRequestFromMediaTransport) {
- EXPECT_CALL(encoder_, SendKeyFrame()).Times(1);
- encoder_rtcp_feedback_.OnKeyFrameRequested(kSsrc);
-}
-
} // namespace webrtc
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 8f7d612..ad8c808 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -22,7 +22,6 @@
#include "api/rtc_event_log_output_file.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
-#include "api/transport/media/media_transport_config.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_encoder.h"
#include "call/fake_network_pipe.h"
@@ -1410,8 +1409,7 @@
}
void VideoQualityTest::SetupAudio(Transport* transport) {
- AudioSendStream::Config audio_send_config(transport,
- webrtc::MediaTransportConfig());
+ AudioSendStream::Config audio_send_config(transport);
audio_send_config.rtp.ssrc = kAudioSendSsrc;
// Add extension to enable audio send side BWE, and allow audio bit rate
diff --git a/video/video_receive_stream.cc b/video/video_receive_stream.cc
index a683f7d..8213c64 100644
--- a/video/video_receive_stream.cc
+++ b/video/video_receive_stream.cc
@@ -125,40 +125,6 @@
const char* ImplementationName() const override { return "NullVideoDecoder"; }
};
-// Inherit video_coding::EncodedFrame, which is the class used by
-// video_coding::FrameBuffer and other components in the receive pipeline. It's
-// a subclass of EncodedImage, and it always owns the buffer.
-class EncodedFrameForMediaTransport : public video_coding::EncodedFrame {
- public:
- explicit EncodedFrameForMediaTransport(
- MediaTransportEncodedVideoFrame frame) {
- // TODO(nisse): This is ugly. We copy the EncodedImage (a base class of
- // ours, in several steps), to get all the meta data. We should be using
- // std::move in some way. Then we also need to handle the case of an unowned
- // buffer, in which case we need to make an owned copy.
- *static_cast<class EncodedImage*>(this) = frame.encoded_image();
-
- // If we don't already own the buffer, make a copy.
- Retain();
-
- _payloadType = static_cast<uint8_t>(frame.payload_type());
-
- // TODO(nisse): frame_id and picture_id are probably not the same thing. For
- // a single layer, this should be good enough.
- id.picture_id = frame.frame_id();
- id.spatial_layer = frame.encoded_image().SpatialIndex().value_or(0);
- num_references = std::min(static_cast<size_t>(kMaxFrameReferences),
- frame.referenced_frame_ids().size());
- for (size_t i = 0; i < num_references; i++) {
- references[i] = frame.referenced_frame_ids()[i];
- }
- }
-
- // TODO(nisse): Implement. Not sure how they are used.
- int64_t ReceivedTime() const override { return 0; }
- int64_t RenderTime() const override { return 0; }
-};
-
// TODO(https://bugs.webrtc.org/9974): Consider removing this workaround.
// Maximum time between frames before resetting the FrameBuffer to avoid RTP
// timestamps wraparound to affect FrameBuffer.
@@ -238,23 +204,18 @@
new video_coding::FrameBuffer(clock_, timing_.get(), &stats_proxy_));
process_thread_->RegisterModule(&rtp_stream_sync_, RTC_FROM_HERE);
- if (config_.media_transport()) {
- config_.media_transport()->SetReceiveVideoSink(this);
- config_.media_transport()->AddRttObserver(this);
+ // Register with RtpStreamReceiverController.
+ media_receiver_ = receiver_controller->CreateReceiver(
+ config_.rtp.remote_ssrc, &rtp_video_stream_receiver_);
+ if (config_.rtp.rtx_ssrc) {
+ rtx_receive_stream_ = std::make_unique<RtxReceiveStream>(
+ &rtp_video_stream_receiver_, config.rtp.rtx_associated_payload_types,
+ config_.rtp.remote_ssrc, rtp_receive_statistics_.get());
+ rtx_receiver_ = receiver_controller->CreateReceiver(
+ config_.rtp.rtx_ssrc, rtx_receive_stream_.get());
} else {
- // Register with RtpStreamReceiverController.
- media_receiver_ = receiver_controller->CreateReceiver(
- config_.rtp.remote_ssrc, &rtp_video_stream_receiver_);
- if (config_.rtp.rtx_ssrc) {
- rtx_receive_stream_ = std::make_unique<RtxReceiveStream>(
- &rtp_video_stream_receiver_, config.rtp.rtx_associated_payload_types,
- config_.rtp.remote_ssrc, rtp_receive_statistics_.get());
- rtx_receiver_ = receiver_controller->CreateReceiver(
- config_.rtp.rtx_ssrc, rtx_receive_stream_.get());
- } else {
- rtp_receive_statistics_->EnableRetransmitDetection(config.rtp.remote_ssrc,
- true);
- }
+ rtp_receive_statistics_->EnableRetransmitDetection(config.rtp.remote_ssrc,
+ true);
}
}
@@ -281,10 +242,6 @@
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
RTC_LOG(LS_INFO) << "~VideoReceiveStream: " << config_.ToString();
Stop();
- if (config_.media_transport()) {
- config_.media_transport()->SetReceiveVideoSink(nullptr);
- config_.media_transport()->RemoveRttObserver(this);
- }
process_thread_->DeRegisterModule(&rtp_stream_sync_);
}
@@ -536,11 +493,7 @@
}
void VideoReceiveStream::RequestKeyFrame(int64_t timestamp_ms) {
- if (config_.media_transport()) {
- config_.media_transport()->RequestKeyFrame(config_.rtp.remote_ssrc);
- } else {
- rtp_video_stream_receiver_.RequestKeyFrame();
- }
+ rtp_video_stream_receiver_.RequestKeyFrame();
last_keyframe_request_ms_ = timestamp_ms;
}
@@ -573,22 +526,12 @@
rtp_video_stream_receiver_.FrameContinuous(last_continuous_pid);
}
-void VideoReceiveStream::OnData(uint64_t channel_id,
- MediaTransportEncodedVideoFrame frame) {
- OnCompleteFrame(
- std::make_unique<EncodedFrameForMediaTransport>(std::move(frame)));
-}
-
void VideoReceiveStream::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
RTC_DCHECK_RUN_ON(&module_process_sequence_checker_);
frame_buffer_->UpdateRtt(max_rtt_ms);
rtp_video_stream_receiver_.UpdateRtt(max_rtt_ms);
}
-void VideoReceiveStream::OnRttUpdated(int64_t rtt_ms) {
- frame_buffer_->UpdateRtt(rtt_ms);
-}
-
int VideoReceiveStream::id() const {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
return config_.rtp.remote_ssrc;
diff --git a/video/video_receive_stream.h b/video/video_receive_stream.h
index 7c68563..2a4e0d1 100644
--- a/video/video_receive_stream.h
+++ b/video/video_receive_stream.h
@@ -15,7 +15,6 @@
#include <vector>
#include "api/task_queue/task_queue_factory.h"
-#include "api/transport/media/media_transport_interface.h"
#include "call/rtp_packet_sink_interface.h"
#include "call/syncable.h"
#include "call/video_receive_stream.h"
@@ -49,9 +48,7 @@
public NackSender,
public video_coding::OnCompleteFrameCallback,
public Syncable,
- public CallStatsObserver,
- public MediaTransportVideoSinkInterface,
- public MediaTransportRttObserver {
+ public CallStatsObserver {
public:
VideoReceiveStream(TaskQueueFactory* task_queue_factory,
RtpStreamReceiverControllerInterface* receiver_controller,
@@ -110,17 +107,9 @@
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override;
- // Implements MediaTransportVideoSinkInterface, converts the received frame to
- // OnCompleteFrameCallback
- void OnData(uint64_t channel_id,
- MediaTransportEncodedVideoFrame frame) override;
-
// Implements CallStatsObserver::OnRttUpdate
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
- // Implements MediaTransportRttObserver::OnRttUpdated
- void OnRttUpdated(int64_t rtt_ms) override;
-
// Implements Syncable.
int id() const override;
absl::optional<Syncable::Info> GetInfo() const override;
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index 12d9dac..8fae407 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -103,7 +103,7 @@
event_log, &config_, encoder_config.max_bitrate_bps,
encoder_config.bitrate_priority, suspended_ssrcs,
suspended_payload_states, encoder_config.content_type,
- std::move(fec_controller), config_.media_transport));
+ std::move(fec_controller)));
},
[this]() { thread_sync_event_.Set(); }));
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index 31dddcc..97f3bb7 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -181,8 +181,7 @@
std::map<uint32_t, RtpState> suspended_ssrcs,
std::map<uint32_t, RtpPayloadState> suspended_payload_states,
VideoEncoderConfig::ContentType content_type,
- std::unique_ptr<FecController> fec_controller,
- MediaTransportInterface* media_transport)
+ std::unique_ptr<FecController> fec_controller)
: clock_(clock),
has_alr_probing_(config->periodic_alr_bandwidth_probing ||
GetAlrSettings(content_type)),
@@ -216,8 +215,7 @@
event_log,
std::move(fec_controller),
CreateFrameEncryptionConfig(config_))),
- weak_ptr_factory_(this),
- media_transport_(media_transport) {
+ weak_ptr_factory_(this) {
video_stream_encoder->SetFecControllerOverride(rtp_video_sender_);
RTC_DCHECK_RUN_ON(worker_queue_);
RTC_LOG(LS_INFO) << "VideoSendStreamInternal: " << config_->ToString();
@@ -225,14 +223,7 @@
encoder_feedback_.SetRtpVideoSender(rtp_video_sender_);
- if (media_transport_) {
- // The configured ssrc is interpreted as a channel id, so there must be
- // exactly one.
- RTC_DCHECK_EQ(config_->rtp.ssrcs.size(), 1);
- media_transport_->SetKeyFrameRequestCallback(&encoder_feedback_);
- } else {
- RTC_DCHECK(!config_->rtp.ssrcs.empty());
- }
+ RTC_DCHECK(!config_->rtp.ssrcs.empty());
RTC_DCHECK(call_stats_);
RTC_DCHECK(transport_);
RTC_DCHECK_NE(initial_encoder_max_bitrate, 0);
@@ -310,9 +301,6 @@
<< "VideoSendStreamImpl::Stop not called";
RTC_LOG(LS_INFO) << "~VideoSendStreamInternal: " << config_->ToString();
transport_->DestroyRtpVideoSender(rtp_video_sender_);
- if (media_transport_) {
- media_transport_->SetKeyFrameRequestCallback(nullptr);
- }
}
void VideoSendStreamImpl::RegisterProcessThread(
@@ -581,31 +569,8 @@
}
EncodedImageCallback::Result result(EncodedImageCallback::Result::OK);
- if (media_transport_) {
- int64_t frame_id;
- {
- // TODO(nisse): Responsibility for allocation of frame ids should move to
- // VideoStreamEncoder.
- rtc::CritScope cs(&media_transport_id_lock_);
- frame_id = media_transport_frame_id_++;
- }
- // TODO(nisse): Responsibility for reference meta data should be moved
- // upstream, ideally close to the encoders, but probably VideoStreamEncoder
- // will need to do some translation to produce reference info using frame
- // ids.
- std::vector<int64_t> referenced_frame_ids;
- if (encoded_image._frameType != VideoFrameType::kVideoFrameKey) {
- RTC_DCHECK_GT(frame_id, 0);
- referenced_frame_ids.push_back(frame_id - 1);
- }
- media_transport_->SendVideoFrame(
- config_->rtp.ssrcs[0], webrtc::MediaTransportEncodedVideoFrame(
- frame_id, referenced_frame_ids,
- config_->rtp.payload_type, encoded_image));
- } else {
- result = rtp_video_sender_->OnEncodedImage(
- encoded_image, codec_specific_info, fragmentation);
- }
+ result = rtp_video_sender_->OnEncodedImage(encoded_image, codec_specific_info,
+ fragmentation);
// Check if there's a throttled VideoBitrateAllocation that we should try
// sending.
rtc::WeakPtr<VideoSendStreamImpl> send_stream = weak_ptr_;
diff --git a/video/video_send_stream_impl.h b/video/video_send_stream_impl.h
index 091ac0f..4195efc 100644
--- a/video/video_send_stream_impl.h
+++ b/video/video_send_stream_impl.h
@@ -87,8 +87,7 @@
std::map<uint32_t, RtpState> suspended_ssrcs,
std::map<uint32_t, RtpPayloadState> suspended_payload_states,
VideoEncoderConfig::ContentType content_type,
- std::unique_ptr<FecController> fec_controller,
- MediaTransportInterface* media_transport);
+ std::unique_ptr<FecController> fec_controller);
~VideoSendStreamImpl() override;
// RegisterProcessThread register |module_process_thread| with those objects
@@ -199,10 +198,6 @@
};
absl::optional<VbaSendContext> video_bitrate_allocation_context_
RTC_GUARDED_BY(worker_queue_);
- MediaTransportInterface* const media_transport_;
- rtc::CriticalSection media_transport_id_lock_;
- int64_t media_transport_frame_id_ RTC_GUARDED_BY(media_transport_id_lock_) =
- 0;
};
} // namespace internal
} // namespace webrtc
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index ce88a36..1c44cc8 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -137,8 +137,7 @@
&video_stream_encoder_, &event_log_, &config_,
initial_encoder_max_bitrate, initial_encoder_bitrate_priority,
suspended_ssrcs, suspended_payload_states, content_type,
- std::make_unique<FecControllerDefault>(&clock_),
- /*media_transport=*/nullptr);
+ std::make_unique<FecControllerDefault>(&clock_));
}
protected:
