From e0446cb80c6387f2824bd5b24929751c7bb73600 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Niels=20M=C3=B6ller?= Date: Fri, 30 Nov 2018 09:35:52 +0100 Subject: [PATCH] Move implementation of LoopbackMediaTransport to .cc file Needed for coming cls to be able to use rtc_base/timeutils.h, which shouldn't be included by api/ headers. Bug: webrtc:9719 Change-Id: Ia36c0a9218ad505e1eb4f2d9c26d44d5673c2632 Reviewed-on: https://webrtc-review.googlesource.com/c/112580 Reviewed-by: Karl Wiberg Commit-Queue: Niels Moller Cr-Commit-Position: refs/heads/master@{#25855} --- api/BUILD.gn | 2 + api/media_transport_interface.cc | 1 + api/media_transport_interface.h | 1 + api/test/loopback_media_transport.cc | 263 +++++++++++++++++++++++++++ api/test/loopback_media_transport.h | 213 +++------------------- 5 files changed, 289 insertions(+), 191 deletions(-) create mode 100644 api/test/loopback_media_transport.cc diff --git a/api/BUILD.gn b/api/BUILD.gn index f3038db221..5f13009de9 100644 --- a/api/BUILD.gn +++ b/api/BUILD.gn @@ -648,6 +648,7 @@ if (rtc_include_tests) { testonly = true sources = [ + "test/loopback_media_transport.cc", "test/loopback_media_transport.h", ] @@ -655,6 +656,7 @@ if (rtc_include_tests) { ":libjingle_peerconnection_api", "../rtc_base:checks", "../rtc_base:rtc_base", + "//third_party/abseil-cpp/absl/memory", ] } diff --git a/api/media_transport_interface.cc b/api/media_transport_interface.cc index 8999e083f0..d4c925eeff 100644 --- a/api/media_transport_interface.cc +++ b/api/media_transport_interface.cc @@ -124,6 +124,7 @@ void MediaTransportEncodedVideoFrame::Retain() { } SendDataParams::SendDataParams() = default; +SendDataParams::SendDataParams(const SendDataParams&) = default; RTCErrorOr> MediaTransportFactory::CreateMediaTransport( diff --git a/api/media_transport_interface.h b/api/media_transport_interface.h index 9dee4f9a41..feebd88efd 100644 --- a/api/media_transport_interface.h +++ b/api/media_transport_interface.h @@ -268,6 +268,7 @@ enum class DataMessageType { // unreliable delivery. struct SendDataParams { SendDataParams(); + SendDataParams(const SendDataParams&); DataMessageType type = DataMessageType::kText; diff --git a/api/test/loopback_media_transport.cc b/api/test/loopback_media_transport.cc new file mode 100644 index 0000000000..609481367b --- /dev/null +++ b/api/test/loopback_media_transport.cc @@ -0,0 +1,263 @@ +/* + * Copyright 2018 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "api/test/loopback_media_transport.h" + +#include "absl/memory/memory.h" + +namespace webrtc { + +namespace { + +// Wrapper used to hand out unique_ptrs to loopback media transports without +// ownership changes. +class WrapperMediaTransport : public MediaTransportInterface { + public: + explicit WrapperMediaTransport(MediaTransportInterface* wrapped) + : wrapped_(wrapped) {} + + RTCError SendAudioFrame(uint64_t channel_id, + MediaTransportEncodedAudioFrame frame) override { + return wrapped_->SendAudioFrame(channel_id, std::move(frame)); + } + + RTCError SendVideoFrame( + uint64_t channel_id, + const MediaTransportEncodedVideoFrame& frame) override { + return wrapped_->SendVideoFrame(channel_id, frame); + } + + RTCError RequestKeyFrame(uint64_t channel_id) override { + return wrapped_->RequestKeyFrame(channel_id); + } + + void SetReceiveAudioSink(MediaTransportAudioSinkInterface* sink) override { + wrapped_->SetReceiveAudioSink(sink); + } + + void SetReceiveVideoSink(MediaTransportVideoSinkInterface* sink) override { + wrapped_->SetReceiveVideoSink(sink); + } + + void SetMediaTransportStateCallback( + MediaTransportStateCallback* callback) override { + wrapped_->SetMediaTransportStateCallback(callback); + } + + RTCError SendData(int channel_id, + const SendDataParams& params, + const rtc::CopyOnWriteBuffer& buffer) override { + return wrapped_->SendData(channel_id, params, buffer); + } + + RTCError CloseChannel(int channel_id) override { + return wrapped_->CloseChannel(channel_id); + } + + void SetDataSink(DataChannelSink* sink) override { + wrapped_->SetDataSink(sink); + } + + private: + MediaTransportInterface* wrapped_; +}; + +} // namespace + +WrapperMediaTransportFactory::WrapperMediaTransportFactory( + MediaTransportInterface* wrapped) + : wrapped_(wrapped) {} + +RTCErrorOr> +WrapperMediaTransportFactory::CreateMediaTransport( + rtc::PacketTransportInternal* packet_transport, + rtc::Thread* network_thread, + const MediaTransportSettings& settings) { + return {absl::make_unique(wrapped_)}; +} + +MediaTransportPair::LoopbackMediaTransport::LoopbackMediaTransport( + rtc::Thread* thread, + LoopbackMediaTransport* other) + : thread_(thread), other_(other) {} + +MediaTransportPair::LoopbackMediaTransport::~LoopbackMediaTransport() { + rtc::CritScope lock(&sink_lock_); + RTC_CHECK(audio_sink_ == nullptr); + RTC_CHECK(video_sink_ == nullptr); + RTC_CHECK(data_sink_ == nullptr); +} + +RTCError MediaTransportPair::LoopbackMediaTransport::SendAudioFrame( + uint64_t channel_id, + MediaTransportEncodedAudioFrame frame) { + { + rtc::CritScope lock(&stats_lock_); + ++stats_.sent_audio_frames; + } + invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, [this, channel_id, frame] { + other_->OnData(channel_id, std::move(frame)); + }); + return RTCError::OK(); +} + +RTCError MediaTransportPair::LoopbackMediaTransport::SendVideoFrame( + uint64_t channel_id, + const MediaTransportEncodedVideoFrame& frame) { + { + rtc::CritScope lock(&stats_lock_); + ++stats_.sent_video_frames; + } + // Ensure that we own the referenced data. + MediaTransportEncodedVideoFrame frame_copy = frame; + frame_copy.Retain(); + invoker_.AsyncInvoke( + RTC_FROM_HERE, thread_, [this, channel_id, frame_copy] { + other_->OnData(channel_id, std::move(frame_copy)); + }); + return RTCError::OK(); +} + +RTCError MediaTransportPair::LoopbackMediaTransport::RequestKeyFrame( + uint64_t channel_id) { + return RTCError::OK(); +} + +void MediaTransportPair::LoopbackMediaTransport::SetReceiveAudioSink( + MediaTransportAudioSinkInterface* sink) { + rtc::CritScope lock(&sink_lock_); + if (sink) { + RTC_CHECK(audio_sink_ == nullptr); + } + audio_sink_ = sink; +} + +void MediaTransportPair::LoopbackMediaTransport::SetReceiveVideoSink( + MediaTransportVideoSinkInterface* sink) { + rtc::CritScope lock(&sink_lock_); + if (sink) { + RTC_CHECK(video_sink_ == nullptr); + } + video_sink_ = sink; +} + +void MediaTransportPair::LoopbackMediaTransport::SetMediaTransportStateCallback( + MediaTransportStateCallback* callback) { + rtc::CritScope lock(&sink_lock_); + state_callback_ = callback; + invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, [this] { + RTC_DCHECK_RUN_ON(thread_); + OnStateChanged(); + }); +} + +RTCError MediaTransportPair::LoopbackMediaTransport::SendData( + int channel_id, + const SendDataParams& params, + const rtc::CopyOnWriteBuffer& buffer) { + invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, + [this, channel_id, params, buffer] { + other_->OnData(channel_id, params.type, buffer); + }); + return RTCError::OK(); +} + +RTCError MediaTransportPair::LoopbackMediaTransport::CloseChannel( + int channel_id) { + invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, [this, channel_id] { + other_->OnRemoteCloseChannel(channel_id); + rtc::CritScope lock(&sink_lock_); + if (data_sink_) { + data_sink_->OnChannelClosed(channel_id); + } + }); + return RTCError::OK(); +} + +void MediaTransportPair::LoopbackMediaTransport::SetDataSink( + DataChannelSink* sink) { + rtc::CritScope lock(&sink_lock_); + data_sink_ = sink; +} +void MediaTransportPair::LoopbackMediaTransport::SetState( + MediaTransportState state) { + invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, [this, state] { + RTC_DCHECK_RUN_ON(thread_); + state_ = state; + OnStateChanged(); + }); +} + +void MediaTransportPair::LoopbackMediaTransport::FlushAsyncInvokes() { + invoker_.Flush(thread_); +} + +MediaTransportPair::Stats +MediaTransportPair::LoopbackMediaTransport::GetStats() { + rtc::CritScope lock(&stats_lock_); + return stats_; +} + +void MediaTransportPair::LoopbackMediaTransport::OnData( + uint64_t channel_id, + MediaTransportEncodedAudioFrame frame) { + { + rtc::CritScope lock(&sink_lock_); + if (audio_sink_) { + audio_sink_->OnData(channel_id, frame); + } + } + { + rtc::CritScope lock(&stats_lock_); + ++stats_.received_audio_frames; + } +} + +void MediaTransportPair::LoopbackMediaTransport::OnData( + uint64_t channel_id, + MediaTransportEncodedVideoFrame frame) { + { + rtc::CritScope lock(&sink_lock_); + if (video_sink_) { + video_sink_->OnData(channel_id, frame); + } + } + { + rtc::CritScope lock(&stats_lock_); + ++stats_.received_video_frames; + } +} + +void MediaTransportPair::LoopbackMediaTransport::OnData( + int channel_id, + DataMessageType type, + const rtc::CopyOnWriteBuffer& buffer) { + rtc::CritScope lock(&sink_lock_); + if (data_sink_) { + data_sink_->OnDataReceived(channel_id, type, buffer); + } +} + +void MediaTransportPair::LoopbackMediaTransport::OnRemoteCloseChannel( + int channel_id) { + rtc::CritScope lock(&sink_lock_); + if (data_sink_) { + data_sink_->OnChannelClosing(channel_id); + data_sink_->OnChannelClosed(channel_id); + } +} + +void MediaTransportPair::LoopbackMediaTransport::OnStateChanged() { + rtc::CritScope lock(&sink_lock_); + if (state_callback_) { + state_callback_->OnStateChanged(state_); + } +} +} // namespace webrtc diff --git a/api/test/loopback_media_transport.h b/api/test/loopback_media_transport.h index 26207890f3..d520c20fc4 100644 --- a/api/test/loopback_media_transport.h +++ b/api/test/loopback_media_transport.h @@ -23,69 +23,15 @@ namespace webrtc { // Wrapper used to hand out unique_ptrs to loopback media transports without -// ownership changes. -class WrapperMediaTransport : public MediaTransportInterface { - public: - explicit WrapperMediaTransport(MediaTransportInterface* wrapped) - : wrapped_(wrapped) {} - - RTCError SendAudioFrame(uint64_t channel_id, - MediaTransportEncodedAudioFrame frame) override { - return wrapped_->SendAudioFrame(channel_id, std::move(frame)); - } - - RTCError SendVideoFrame( - uint64_t channel_id, - const MediaTransportEncodedVideoFrame& frame) override { - return wrapped_->SendVideoFrame(channel_id, frame); - } - - RTCError RequestKeyFrame(uint64_t channel_id) override { - return wrapped_->RequestKeyFrame(channel_id); - } - - void SetReceiveAudioSink(MediaTransportAudioSinkInterface* sink) override { - wrapped_->SetReceiveAudioSink(sink); - } - - void SetReceiveVideoSink(MediaTransportVideoSinkInterface* sink) override { - wrapped_->SetReceiveVideoSink(sink); - } - - void SetMediaTransportStateCallback( - MediaTransportStateCallback* callback) override { - wrapped_->SetMediaTransportStateCallback(callback); - } - - RTCError SendData(int channel_id, - const SendDataParams& params, - const rtc::CopyOnWriteBuffer& buffer) override { - return wrapped_->SendData(channel_id, params, buffer); - } - - RTCError CloseChannel(int channel_id) override { - return wrapped_->CloseChannel(channel_id); - } - - void SetDataSink(DataChannelSink* sink) override { - wrapped_->SetDataSink(sink); - } - - private: - MediaTransportInterface* wrapped_; -}; - +// ownership changes to the underlying transport. class WrapperMediaTransportFactory : public MediaTransportFactory { public: - explicit WrapperMediaTransportFactory(MediaTransportInterface* wrapped) - : wrapped_(wrapped) {} + explicit WrapperMediaTransportFactory(MediaTransportInterface* wrapped); RTCErrorOr> CreateMediaTransport( rtc::PacketTransportInternal* packet_transport, rtc::Thread* network_thread, - const MediaTransportSettings& settings) override { - return {absl::make_unique(wrapped_)}; - } + const MediaTransportSettings& settings) override; private: MediaTransportInterface* wrapped_; @@ -133,167 +79,52 @@ class MediaTransportPair { private: class LoopbackMediaTransport : public MediaTransportInterface { public: - LoopbackMediaTransport(rtc::Thread* thread, LoopbackMediaTransport* other) - : thread_(thread), other_(other) {} + LoopbackMediaTransport(rtc::Thread* thread, LoopbackMediaTransport* other); - ~LoopbackMediaTransport() { - rtc::CritScope lock(&sink_lock_); - RTC_CHECK(audio_sink_ == nullptr); - RTC_CHECK(video_sink_ == nullptr); - RTC_CHECK(data_sink_ == nullptr); - } + ~LoopbackMediaTransport() override; RTCError SendAudioFrame(uint64_t channel_id, - MediaTransportEncodedAudioFrame frame) override { - { - rtc::CritScope lock(&stats_lock_); - ++stats_.sent_audio_frames; - } - invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, - [this, channel_id, frame] { - other_->OnData(channel_id, std::move(frame)); - }); - return RTCError::OK(); - }; + MediaTransportEncodedAudioFrame frame) override; RTCError SendVideoFrame( uint64_t channel_id, - const MediaTransportEncodedVideoFrame& frame) override { - { - rtc::CritScope lock(&stats_lock_); - ++stats_.sent_video_frames; - } - // Ensure that we own the referenced data. - MediaTransportEncodedVideoFrame frame_copy = frame; - frame_copy.Retain(); - invoker_.AsyncInvoke( - RTC_FROM_HERE, thread_, [this, channel_id, frame_copy] { - other_->OnData(channel_id, std::move(frame_copy)); - }); - return RTCError::OK(); - } + const MediaTransportEncodedVideoFrame& frame) override; - RTCError RequestKeyFrame(uint64_t channel_id) override { - return RTCError::OK(); - } + RTCError RequestKeyFrame(uint64_t channel_id) override; - void SetReceiveAudioSink(MediaTransportAudioSinkInterface* sink) override { - rtc::CritScope lock(&sink_lock_); - if (sink) { - RTC_CHECK(audio_sink_ == nullptr); - } - audio_sink_ = sink; - } + void SetReceiveAudioSink(MediaTransportAudioSinkInterface* sink) override; - void SetReceiveVideoSink(MediaTransportVideoSinkInterface* sink) override { - rtc::CritScope lock(&sink_lock_); - if (sink) { - RTC_CHECK(video_sink_ == nullptr); - } - video_sink_ = sink; - } + void SetReceiveVideoSink(MediaTransportVideoSinkInterface* sink) override; void SetMediaTransportStateCallback( - MediaTransportStateCallback* callback) override { - rtc::CritScope lock(&sink_lock_); - state_callback_ = callback; - invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, [this] { - RTC_DCHECK_RUN_ON(thread_); - OnStateChanged(); - }); - } + MediaTransportStateCallback* callback) override; RTCError SendData(int channel_id, const SendDataParams& params, - const rtc::CopyOnWriteBuffer& buffer) override { - invoker_.AsyncInvoke( - RTC_FROM_HERE, thread_, [this, channel_id, params, buffer] { - other_->OnData(channel_id, params.type, buffer); - }); - return RTCError::OK(); - } + const rtc::CopyOnWriteBuffer& buffer) override; - RTCError CloseChannel(int channel_id) override { - invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, [this, channel_id] { - other_->OnRemoteCloseChannel(channel_id); - rtc::CritScope lock(&sink_lock_); - if (data_sink_) { - data_sink_->OnChannelClosed(channel_id); - } - }); - return RTCError::OK(); - } + RTCError CloseChannel(int channel_id) override; - void SetDataSink(DataChannelSink* sink) override { - rtc::CritScope lock(&sink_lock_); - data_sink_ = sink; - } + void SetDataSink(DataChannelSink* sink) override; - void SetState(MediaTransportState state) { - invoker_.AsyncInvoke(RTC_FROM_HERE, thread_, [this, state] { - RTC_DCHECK_RUN_ON(thread_); - state_ = state; - OnStateChanged(); - }); - } + void SetState(MediaTransportState state); - void FlushAsyncInvokes() { invoker_.Flush(thread_); } + void FlushAsyncInvokes(); - Stats GetStats() { - rtc::CritScope lock(&stats_lock_); - return stats_; - } + Stats GetStats(); private: - void OnData(uint64_t channel_id, MediaTransportEncodedAudioFrame frame) { - { - rtc::CritScope lock(&sink_lock_); - if (audio_sink_) { - audio_sink_->OnData(channel_id, frame); - } - } - { - rtc::CritScope lock(&stats_lock_); - ++stats_.received_audio_frames; - } - } + void OnData(uint64_t channel_id, MediaTransportEncodedAudioFrame frame); - void OnData(uint64_t channel_id, MediaTransportEncodedVideoFrame frame) { - { - rtc::CritScope lock(&sink_lock_); - if (video_sink_) { - video_sink_->OnData(channel_id, frame); - } - } - { - rtc::CritScope lock(&stats_lock_); - ++stats_.received_video_frames; - } - } + void OnData(uint64_t channel_id, MediaTransportEncodedVideoFrame frame); void OnData(int channel_id, DataMessageType type, - const rtc::CopyOnWriteBuffer& buffer) { - rtc::CritScope lock(&sink_lock_); - if (data_sink_) { - data_sink_->OnDataReceived(channel_id, type, buffer); - } - } + const rtc::CopyOnWriteBuffer& buffer); - void OnRemoteCloseChannel(int channel_id) { - rtc::CritScope lock(&sink_lock_); - if (data_sink_) { - data_sink_->OnChannelClosing(channel_id); - data_sink_->OnChannelClosed(channel_id); - } - } + void OnRemoteCloseChannel(int channel_id); - void OnStateChanged() RTC_RUN_ON(thread_) { - rtc::CritScope lock(&sink_lock_); - if (state_callback_) { - state_callback_->OnStateChanged(state_); - } - } + void OnStateChanged() RTC_RUN_ON(thread_); rtc::Thread* const thread_; rtc::CriticalSection sink_lock_;