admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Inject TaskQueueFactory to video streams.

Browse Source 
Bug: webrtc:10365
Change-Id: Ib655d8eac4467926bcb86cf2cb3728eabf5342d8
Reviewed-on: https://webrtc-review.googlesource.com/c/125089
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26921}
This commit is contained in:
Sebastian Jansson 2019-03-01 11:50:20 +01:00 committed by Commit Bot
parent 859abef68c
commit 74682c1191
18 changed files with 71 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
BUILD.gn
View File

@ -476,6 +476,7 @@ if (rtc_include_tests) {
"api:rtc_api_unittests",
"api/audio/test:audio_api_unittests",
"api/audio_codecs/test:audio_codecs_api_unittests",
"api/task_queue:global_task_queue_factory",
"api/video/test:rtc_api_video_unittests",
"api/video_codecs/test:video_codecs_api_unittests",
"call:fake_network_pipe_unittests",

2
api/video/BUILD.gn
View File

@ -209,6 +209,8 @@ rtc_source_set("video_stream_encoder_create") {
":video_stream_encoder",
"../../api:scoped_refptr",
"../../video:video_stream_encoder_impl",
"../task_queue",
"../task_queue:global_task_queue_factory",
"../video_codecs:video_codecs_api",
"//third_party/abseil-cpp/absl/memory",
]

14
api/video/video_stream_encoder_create.cc
View File

@ -11,6 +11,7 @@
#include "api/video/video_stream_encoder_create.h"
#include "absl/memory/memory.h"
#include "api/task_queue/global_task_queue_factory.h"
#include "video/overuse_frame_detector.h"
#include "video/video_stream_encoder.h"
@ -19,8 +20,19 @@ std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
uint32_t number_of_cores,
VideoStreamEncoderObserver* encoder_stats_observer,
const VideoStreamEncoderSettings& settings) {
return CreateVideoStreamEncoder(&GlobalTaskQueueFactory(), number_of_cores,
encoder_stats_observer, settings);
}
std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
TaskQueueFactory* task_queue_factory,
uint32_t number_of_cores,
VideoStreamEncoderObserver* encoder_stats_observer,
const VideoStreamEncoderSettings& settings) {
return absl::make_unique<VideoStreamEncoder>(
number_of_cores, encoder_stats_observer, settings,
absl::make_unique<OveruseFrameDetector>(encoder_stats_observer));
absl::make_unique<OveruseFrameDetector>(encoder_stats_observer),
task_queue_factory);
}
} // namespace webrtc

6
api/video/video_stream_encoder_create.h
View File

@ -14,6 +14,7 @@
#include <stdint.h>
#include <memory>
#include "api/task_queue/task_queue_factory.h"
#include "api/video/video_frame.h"
#include "api/video/video_sink_interface.h"
#include "api/video/video_stream_encoder_interface.h"
@ -27,6 +28,11 @@ std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
VideoStreamEncoderObserver* encoder_stats_observer,
const VideoStreamEncoderSettings& settings);
std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
TaskQueueFactory* task_queue_factory,
uint32_t number_of_cores,
VideoStreamEncoderObserver* encoder_stats_observer,
const VideoStreamEncoderSettings& settings);
} // namespace webrtc
#endif // API_VIDEO_VIDEO_STREAM_ENCODER_CREATE_H_

1
call/BUILD.gn
View File

@ -219,6 +219,7 @@ rtc_static_library("call") {
"../api:libjingle_peerconnection_api",
"../api:simulated_network_api",
"../api:transport_api",
"../api/task_queue:global_task_queue_factory",
"../api/transport:network_control",
"../api/units:time_delta",
"../api/video_codecs:video_codecs_api",

7
call/call.cc
View File

@ -18,6 +18,7 @@
#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "api/task_queue/global_task_queue_factory.h"
#include "api/transport/network_control.h"
#include "audio/audio_receive_stream.h"
#include "audio/audio_send_stream.h"
@ -792,8 +793,8 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream(
// having it injected.
VideoSendStream* send_stream = new VideoSendStream(
num_cpu_cores_, module_process_thread_.get(),
transport_send_ptr_->GetWorkerQueue(), call_stats_.get(),
transport_send_ptr_, bitrate_allocator_.get(),
transport_send_ptr_->GetWorkerQueue(), &GlobalTaskQueueFactory(),
call_stats_.get(), transport_send_ptr_, bitrate_allocator_.get(),
video_send_delay_stats_.get(), event_log_, std::move(config),
std::move(encoder_config), suspended_video_send_ssrcs_,
suspended_video_payload_states_, std::move(fec_controller));
@ -874,7 +875,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
RegisterRateObserver();
VideoReceiveStream* receive_stream = new VideoReceiveStream(
&video_receiver_controller_, num_cpu_cores_,
&GlobalTaskQueueFactory(), &video_receiver_controller_, num_cpu_cores_,
transport_send_ptr_->packet_router(), std::move(configuration),
module_process_thread_.get(), call_stats_.get());

1
common_video/BUILD.gn
View File

@ -41,6 +41,7 @@ rtc_static_library("common_video") {
deps = [
"..:webrtc_common",
"../api:scoped_refptr",
"../api/task_queue",
"../api/video:encoded_image",
"../api/video:video_bitrate_allocation",
"../api/video:video_bitrate_allocator",

4
common_video/include/incoming_video_stream.h
View File

@ -13,6 +13,7 @@
#include <stdint.h>
#include "api/task_queue/task_queue_factory.h"
#include "api/video/video_frame.h"
#include "api/video/video_sink_interface.h"
#include "common_video/video_render_frames.h"
@ -24,7 +25,8 @@ namespace webrtc {
class IncomingVideoStream : public rtc::VideoSinkInterface<VideoFrame> {
public:
IncomingVideoStream(int32_t delay_ms,
IncomingVideoStream(TaskQueueFactory* task_queue_factory,
int32_t delay_ms,
rtc::VideoSinkInterface<VideoFrame>* callback);
~IncomingVideoStream() override;

9
common_video/incoming_video_stream.cc
View File

@ -19,17 +19,16 @@
#include "rtc_base/trace_event.h"
namespace webrtc {
namespace {
const char kIncomingQueueName[] = "IncomingVideoStream";
}
IncomingVideoStream::IncomingVideoStream(
TaskQueueFactory* task_queue_factory,
int32_t delay_ms,
rtc::VideoSinkInterface<VideoFrame>* callback)
: render_buffers_(delay_ms),
callback_(callback),
incoming_render_queue_(kIncomingQueueName,
rtc::TaskQueue::Priority::HIGH) {}
incoming_render_queue_(task_queue_factory->CreateTaskQueue(
"IncomingVideoStream",
TaskQueueFactory::Priority::HIGH)) {}
IncomingVideoStream::~IncomingVideoStream() {
RTC_DCHECK(main_thread_checker_.CalledOnValidThread());

2
video/BUILD.gn
View File

@ -56,6 +56,7 @@ rtc_static_library("video") {
"../api:libjingle_peerconnection_api",
"../api:scoped_refptr",
"../api:transport_api",
"../api/task_queue",
"../api/video:encoded_image",
"../api/video:video_bitrate_allocation",
"../api/video:video_bitrate_allocator",
@ -478,6 +479,7 @@ if (rtc_include_tests) {
"../api:mock_frame_decryptor",
"../api:scoped_refptr",
"../api:simulated_network_api",
"../api/task_queue:global_task_queue_factory",
"../api/test/video:function_video_factory",
"../api/units:data_rate",
"../api/video:builtin_video_bitrate_allocator_factory",

12
video/video_receive_stream.cc
View File

@ -164,6 +164,7 @@ constexpr int kInactiveStreamThresholdMs = 600000; // 10 minutes.
namespace internal {
VideoReceiveStream::VideoReceiveStream(
TaskQueueFactory* task_queue_factory,
RtpStreamReceiverControllerInterface* receiver_controller,
int num_cpu_cores,
PacketRouter* packet_router,
@ -172,7 +173,8 @@ VideoReceiveStream::VideoReceiveStream(
CallStats* call_stats,
Clock* clock,
VCMTiming* timing)
: transport_adapter_(config.rtcp_send_transport),
: task_queue_factory_(task_queue_factory),
transport_adapter_(config.rtcp_send_transport),
config_(std::move(config)),
num_cpu_cores_(num_cpu_cores),
process_thread_(process_thread),
@ -251,13 +253,15 @@ VideoReceiveStream::VideoReceiveStream(
}
VideoReceiveStream::VideoReceiveStream(
TaskQueueFactory* task_queue_factory,
RtpStreamReceiverControllerInterface* receiver_controller,
int num_cpu_cores,
PacketRouter* packet_router,
VideoReceiveStream::Config config,
ProcessThread* process_thread,
CallStats* call_stats)
: VideoReceiveStream(receiver_controller,
: VideoReceiveStream(task_queue_factory,
receiver_controller,
num_cpu_cores,
packet_router,
std::move(config),
@ -311,8 +315,8 @@ void VideoReceiveStream::Start() {
transport_adapter_.Enable();
rtc::VideoSinkInterface<VideoFrame>* renderer = nullptr;
if (config_.enable_prerenderer_smoothing) {
incoming_video_stream_.reset(
new IncomingVideoStream(config_.render_delay_ms, this));
incoming_video_stream_.reset(new IncomingVideoStream(
task_queue_factory_, config_.render_delay_ms, this));
renderer = incoming_video_stream_.get();
} else {
renderer = this;

9
video/video_receive_stream.h
View File

@ -15,6 +15,7 @@
#include <vector>
#include "api/media_transport_interface.h"
#include "api/task_queue/task_queue_factory.h"
#include "call/rtp_packet_sink_interface.h"
#include "call/syncable.h"
#include "call/video_receive_stream.h"
@ -52,7 +53,8 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
public MediaTransportVideoSinkInterface,
public MediaTransportRttObserver {
public:
VideoReceiveStream(RtpStreamReceiverControllerInterface* receiver_controller,
VideoReceiveStream(TaskQueueFactory* task_queue_factory,
RtpStreamReceiverControllerInterface* receiver_controller,
int num_cpu_cores,
PacketRouter* packet_router,
VideoReceiveStream::Config config,
@ -60,7 +62,8 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
CallStats* call_stats,
Clock* clock,
VCMTiming* timing);
VideoReceiveStream(RtpStreamReceiverControllerInterface* receiver_controller,
VideoReceiveStream(TaskQueueFactory* task_queue_factory,
RtpStreamReceiverControllerInterface* receiver_controller,
int num_cpu_cores,
PacketRouter* packet_router,
VideoReceiveStream::Config config,
@ -134,6 +137,8 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
rtc::SequencedTaskChecker module_process_sequence_checker_;
rtc::SequencedTaskChecker network_sequence_checker_;
TaskQueueFactory* const task_queue_factory_;
TransportAdapter transport_adapter_;
const VideoReceiveStream::Config config_;
const int num_cpu_cores_;

6
video/video_receive_stream_unittest.cc
View File

@ -14,6 +14,7 @@
#include "test/gmock.h"
#include "test/gtest.h"
#include "api/task_queue/global_task_queue_factory.h"
#include "api/video_codecs/video_decoder.h"
#include "call/rtp_stream_receiver_controller.h"
#include "media/base/fake_video_renderer.h"
@ -100,8 +101,9 @@ class VideoReceiveStreamTest : public testing::Test {
timing_ = new VCMTiming(clock);
video_receive_stream_.reset(new webrtc::internal::VideoReceiveStream(
&rtp_stream_receiver_controller_, kDefaultNumCpuCores, &packet_router_,
config_.Copy(), process_thread_.get(), &call_stats_, clock, timing_));
&GlobalTaskQueueFactory(), &rtp_stream_receiver_controller_,
kDefaultNumCpuCores, &packet_router_, config_.Copy(),
process_thread_.get(), &call_stats_, clock, timing_));
}
protected:

6
video/video_send_stream.cc
View File

@ -68,6 +68,7 @@ VideoSendStream::VideoSendStream(
int num_cpu_cores,
ProcessThread* module_process_thread,
rtc::TaskQueue* worker_queue,
TaskQueueFactory* task_queue_factory,
CallStats* call_stats,
RtpTransportControllerSendInterface* transport,
BitrateAllocatorInterface* bitrate_allocator,
@ -87,8 +88,9 @@ VideoSendStream::VideoSendStream(
RTC_DCHECK(config_.encoder_settings.encoder_factory);
RTC_DCHECK(config_.encoder_settings.bitrate_allocator_factory);
video_stream_encoder_ = CreateVideoStreamEncoder(num_cpu_cores, &stats_proxy_,
config_.encoder_settings);
video_stream_encoder_ =
CreateVideoStreamEncoder(task_queue_factory, num_cpu_cores, &stats_proxy_,
config_.encoder_settings);
// TODO(srte): Initialization should not be done posted on a task queue.
// Note that the posted task must not outlive this scope since the closure
// references local variables.

1
video/video_send_stream.h
View File

@ -56,6 +56,7 @@ class VideoSendStream : public webrtc::VideoSendStream {
int num_cpu_cores,
ProcessThread* module_process_thread,
rtc::TaskQueue* worker_queue,
TaskQueueFactory* task_queue_factory,
CallStats* call_stats,
RtpTransportControllerSendInterface* transport,
BitrateAllocatorInterface* bitrate_allocator,

7
video/video_stream_encoder.cc
View File

@ -422,7 +422,8 @@ VideoStreamEncoder::VideoStreamEncoder(
uint32_t number_of_cores,
VideoStreamEncoderObserver* encoder_stats_observer,
const VideoStreamEncoderSettings& settings,
std::unique_ptr<OveruseFrameDetector> overuse_detector)
std::unique_ptr<OveruseFrameDetector> overuse_detector,
TaskQueueFactory* task_queue_factory)
: shutdown_event_(true /* manual_reset */, false),
number_of_cores_(number_of_cores),
initial_framedrop_(0),
@ -464,7 +465,9 @@ VideoStreamEncoder::VideoStreamEncoder(
next_frame_types_(1, kVideoFrameDelta),
frame_encoder_timer_(this),
experiment_groups_(GetExperimentGroups()),
encoder_queue_("EncoderQueue") {
encoder_queue_(task_queue_factory->CreateTaskQueue(
"EncoderQueue",
TaskQueueFactory::Priority::NORMAL)) {
RTC_DCHECK(encoder_stats_observer);
RTC_DCHECK(overuse_detector_);
RTC_DCHECK_GE(number_of_cores, 1);

3
video/video_stream_encoder.h
View File

@ -56,7 +56,8 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
VideoStreamEncoder(uint32_t number_of_cores,
VideoStreamEncoderObserver* encoder_stats_observer,
const VideoStreamEncoderSettings& settings,
std::unique_ptr<OveruseFrameDetector> overuse_detector);
std::unique_ptr<OveruseFrameDetector> overuse_detector,
TaskQueueFactory* task_queue_factory);
~VideoStreamEncoder() override;
void SetSource(rtc::VideoSourceInterface<VideoFrame>* source,

4
video/video_stream_encoder_unittest.cc
View File

@ -14,6 +14,7 @@
#include <limits>
#include <utility>
#include "api/task_queue/global_task_queue_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_bitrate_allocation.h"
@ -104,7 +105,8 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
settings,
std::unique_ptr<OveruseFrameDetector>(
overuse_detector_proxy_ =
new CpuOveruseDetectorProxy(stats_proxy))) {}
new CpuOveruseDetectorProxy(stats_proxy)),
&GlobalTaskQueueFactory()) {}
void PostTaskAndWait(bool down, AdaptReason reason) {
rtc::Event event;