Add peer name to video quality analyzer interface.
Add peer name to video quality analyzer interface to make it possible to
add multipeer support.
Change-Id: I2570cd4481503c8634bdd91208b3dd2fa1d62029
Bug: webrtc:11631
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176329
Reviewed-by: Andrey Logvin <landrey@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31395}
diff --git a/api/BUILD.gn b/api/BUILD.gn
index 0a0a501..d5c8229 100644
--- a/api/BUILD.gn
+++ b/api/BUILD.gn
@@ -290,6 +290,7 @@
"video:video_frame",
"video:video_rtp_headers",
"video_codecs:video_codecs_api",
+ "//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
}
diff --git a/api/test/video_quality_analyzer_interface.h b/api/test/video_quality_analyzer_interface.h
index 0d3f441..5bf8a1a 100644
--- a/api/test/video_quality_analyzer_interface.h
+++ b/api/test/video_quality_analyzer_interface.h
@@ -14,6 +14,7 @@
#include <memory>
#include <string>
+#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/test/stats_observer_interface.h"
#include "api/video/encoded_image.h"
@@ -79,35 +80,55 @@
virtual void Start(std::string test_case_name, int max_threads_count) {}
// Will be called when frame was generated from the input stream.
+ // |peer_name| is name of the peer on which side frame was captured.
// Returns frame id, that will be set by framework to the frame.
- virtual uint16_t OnFrameCaptured(const std::string& stream_label,
+ virtual uint16_t OnFrameCaptured(absl::string_view peer_name,
+ const std::string& stream_label,
const VideoFrame& frame) = 0;
// Will be called before calling the encoder.
- virtual void OnFramePreEncode(const VideoFrame& frame) {}
+ // |peer_name| is name of the peer on which side frame came to encoder.
+ virtual void OnFramePreEncode(absl::string_view peer_name,
+ const VideoFrame& frame) {}
// Will be called for each EncodedImage received from encoder. Single
// VideoFrame can produce multiple EncodedImages. Each encoded image will
// have id from VideoFrame.
- virtual void OnFrameEncoded(uint16_t frame_id,
+ // |peer_name| is name of the peer on which side frame was encoded.
+ virtual void OnFrameEncoded(absl::string_view peer_name,
+ uint16_t frame_id,
const EncodedImage& encoded_image,
const EncoderStats& stats) {}
// Will be called for each frame dropped by encoder.
- virtual void OnFrameDropped(EncodedImageCallback::DropReason reason) {}
+ // |peer_name| is name of the peer on which side frame drop was detected.
+ virtual void OnFrameDropped(absl::string_view peer_name,
+ EncodedImageCallback::DropReason reason) {}
// Will be called before calling the decoder.
- virtual void OnFramePreDecode(uint16_t frame_id,
+ // |peer_name| is name of the peer on which side frame was received.
+ virtual void OnFramePreDecode(absl::string_view peer_name,
+ uint16_t frame_id,
const EncodedImage& encoded_image) {}
// Will be called after decoding the frame.
- virtual void OnFrameDecoded(const VideoFrame& frame,
+ // |peer_name| is name of the peer on which side frame was decoded.
+ virtual void OnFrameDecoded(absl::string_view peer_name,
+ const VideoFrame& frame,
const DecoderStats& stats) {}
// Will be called when frame will be obtained from PeerConnection stack.
- virtual void OnFrameRendered(const VideoFrame& frame) {}
+ // |peer_name| is name of the peer on which side frame was rendered.
+ virtual void OnFrameRendered(absl::string_view peer_name,
+ const VideoFrame& frame) {}
// Will be called if encoder return not WEBRTC_VIDEO_CODEC_OK.
// All available codes are listed in
// modules/video_coding/include/video_error_codes.h
- virtual void OnEncoderError(const VideoFrame& frame, int32_t error_code) {}
+ // |peer_name| is name of the peer on which side error acquired.
+ virtual void OnEncoderError(absl::string_view peer_name,
+ const VideoFrame& frame,
+ int32_t error_code) {}
// Will be called if decoder return not WEBRTC_VIDEO_CODEC_OK.
// All available codes are listed in
// modules/video_coding/include/video_error_codes.h
- virtual void OnDecoderError(uint16_t frame_id, int32_t error_code) {}
+ // |peer_name| is name of the peer on which side error acquired.
+ virtual void OnDecoderError(absl::string_view peer_name,
+ uint16_t frame_id,
+ int32_t error_code) {}
// Will be called every time new stats reports are available for the
// Peer Connection identified by |pc_label|.
void OnStatsReports(const std::string& pc_label,
diff --git a/test/pc/e2e/BUILD.gn b/test/pc/e2e/BUILD.gn
index d340f1a..f31bd2c 100644
--- a/test/pc/e2e/BUILD.gn
+++ b/test/pc/e2e/BUILD.gn
@@ -147,6 +147,7 @@
"../../../modules/video_coding:video_codec_interface",
"../../../rtc_base:criticalsection",
"../../../rtc_base:logging",
+ "//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
}
@@ -169,6 +170,7 @@
"../../../modules/video_coding:video_codec_interface",
"../../../rtc_base:criticalsection",
"../../../rtc_base:logging",
+ "//third_party/abseil-cpp/absl/strings",
]
}
@@ -197,6 +199,7 @@
"../../../test:video_test_common",
"../../../test:video_test_support",
"//third_party/abseil-cpp/absl/memory",
+ "//third_party/abseil-cpp/absl/strings",
]
}
@@ -385,6 +388,7 @@
"../../../rtc_base:task_queue_for_test",
"../../../system_wrappers",
"../../../system_wrappers:field_trial",
+ "//third_party/abseil-cpp/absl/strings",
]
}
diff --git a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc
index 786509d..b09292b 100644
--- a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc
+++ b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc
@@ -98,6 +98,7 @@
}
uint16_t DefaultVideoQualityAnalyzer::OnFrameCaptured(
+ absl::string_view peer_name,
const std::string& stream_label,
const webrtc::VideoFrame& frame) {
// |next_frame_id| is atomic, so we needn't lock here.
@@ -172,6 +173,7 @@
}
void DefaultVideoQualityAnalyzer::OnFramePreEncode(
+ absl::string_view peer_name,
const webrtc::VideoFrame& frame) {
rtc::CritScope crit(&lock_);
auto it = frame_stats_.find(frame.id());
@@ -183,6 +185,7 @@
}
void DefaultVideoQualityAnalyzer::OnFrameEncoded(
+ absl::string_view peer_name,
uint16_t frame_id,
const webrtc::EncodedImage& encoded_image,
const EncoderStats& stats) {
@@ -202,11 +205,13 @@
}
void DefaultVideoQualityAnalyzer::OnFrameDropped(
+ absl::string_view peer_name,
webrtc::EncodedImageCallback::DropReason reason) {
// Here we do nothing, because we will see this drop on renderer side.
}
void DefaultVideoQualityAnalyzer::OnFramePreDecode(
+ absl::string_view peer_name,
uint16_t frame_id,
const webrtc::EncodedImage& input_image) {
rtc::CritScope crit(&lock_);
@@ -231,6 +236,7 @@
}
void DefaultVideoQualityAnalyzer::OnFrameDecoded(
+ absl::string_view peer_name,
const webrtc::VideoFrame& frame,
const DecoderStats& stats) {
rtc::CritScope crit(&lock_);
@@ -242,6 +248,7 @@
}
void DefaultVideoQualityAnalyzer::OnFrameRendered(
+ absl::string_view peer_name,
const webrtc::VideoFrame& raw_frame) {
// Copy entire video frame including video buffer to ensure that analyzer
// won't hold any WebRTC internal buffers.
@@ -326,13 +333,15 @@
}
void DefaultVideoQualityAnalyzer::OnEncoderError(
+ absl::string_view peer_name,
const webrtc::VideoFrame& frame,
int32_t error_code) {
RTC_LOG(LS_ERROR) << "Encoder error for frame.id=" << frame.id()
<< ", code=" << error_code;
}
-void DefaultVideoQualityAnalyzer::OnDecoderError(uint16_t frame_id,
+void DefaultVideoQualityAnalyzer::OnDecoderError(absl::string_view peer_name,
+ uint16_t frame_id,
int32_t error_code) {
RTC_LOG(LS_ERROR) << "Decoder error for frame_id=" << frame_id
<< ", code=" << error_code;
diff --git a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h
index 6bebb0f..2f83f23 100644
--- a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h
+++ b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h
@@ -135,20 +135,31 @@
~DefaultVideoQualityAnalyzer() override;
void Start(std::string test_case_name, int max_threads_count) override;
- uint16_t OnFrameCaptured(const std::string& stream_label,
+ uint16_t OnFrameCaptured(absl::string_view peer_name,
+ const std::string& stream_label,
const VideoFrame& frame) override;
- void OnFramePreEncode(const VideoFrame& frame) override;
- void OnFrameEncoded(uint16_t frame_id,
+ void OnFramePreEncode(absl::string_view peer_name,
+ const VideoFrame& frame) override;
+ void OnFrameEncoded(absl::string_view peer_name,
+ uint16_t frame_id,
const EncodedImage& encoded_image,
const EncoderStats& stats) override;
- void OnFrameDropped(EncodedImageCallback::DropReason reason) override;
- void OnFramePreDecode(uint16_t frame_id,
+ void OnFrameDropped(absl::string_view peer_name,
+ EncodedImageCallback::DropReason reason) override;
+ void OnFramePreDecode(absl::string_view peer_name,
+ uint16_t frame_id,
const EncodedImage& input_image) override;
- void OnFrameDecoded(const VideoFrame& frame,
+ void OnFrameDecoded(absl::string_view peer_name,
+ const VideoFrame& frame,
const DecoderStats& stats) override;
- void OnFrameRendered(const VideoFrame& frame) override;
- void OnEncoderError(const VideoFrame& frame, int32_t error_code) override;
- void OnDecoderError(uint16_t frame_id, int32_t error_code) override;
+ void OnFrameRendered(absl::string_view peer_name,
+ const VideoFrame& frame) override;
+ void OnEncoderError(absl::string_view peer_name,
+ const VideoFrame& frame,
+ int32_t error_code) override;
+ void OnDecoderError(absl::string_view peer_name,
+ uint16_t frame_id,
+ int32_t error_code) override;
void Stop() override;
std::string GetStreamLabel(uint16_t frame_id) override;
void OnStatsReports(const std::string& pc_label,
diff --git a/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc b/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
index 1bc29c5..ef6baf9 100644
--- a/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
+++ b/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
@@ -31,6 +31,8 @@
constexpr int kFrameWidth = 320;
constexpr int kFrameHeight = 240;
constexpr char kStreamLabel[] = "video-stream";
+constexpr char kSenderPeerName[] = "alice";
+constexpr char kReceiverPeerName[] = "bob";
VideoFrame NextFrame(test::FrameGeneratorInterface* frame_generator,
int64_t timestamp_us) {
@@ -79,20 +81,22 @@
std::vector<uint16_t> frames_order;
for (int i = 0; i < kMaxFramesInFlightPerStream * 2; ++i) {
VideoFrame frame = NextFrame(frame_generator.get(), i);
- frame.set_id(analyzer.OnFrameCaptured(kStreamLabel, frame));
+ frame.set_id(
+ analyzer.OnFrameCaptured(kSenderPeerName, kStreamLabel, frame));
frames_order.push_back(frame.id());
captured_frames.insert({frame.id(), frame});
- analyzer.OnFramePreEncode(frame);
- analyzer.OnFrameEncoded(frame.id(), FakeEncode(frame),
+ analyzer.OnFramePreEncode(kSenderPeerName, frame);
+ analyzer.OnFrameEncoded(kSenderPeerName, frame.id(), FakeEncode(frame),
VideoQualityAnalyzerInterface::EncoderStats());
}
for (const uint16_t& frame_id : frames_order) {
VideoFrame received_frame = DeepCopy(captured_frames.at(frame_id));
- analyzer.OnFramePreDecode(received_frame.id(), FakeEncode(received_frame));
- analyzer.OnFrameDecoded(received_frame,
+ analyzer.OnFramePreDecode(kReceiverPeerName, received_frame.id(),
+ FakeEncode(received_frame));
+ analyzer.OnFrameDecoded(kReceiverPeerName, received_frame,
VideoQualityAnalyzerInterface::DecoderStats());
- analyzer.OnFrameRendered(received_frame);
+ analyzer.OnFrameRendered(kReceiverPeerName, received_frame);
}
// Give analyzer some time to process frames on async thread. The computations
@@ -126,21 +130,23 @@
std::vector<uint16_t> frames_order;
for (int i = 0; i < kMaxFramesInFlightPerStream * 2; ++i) {
VideoFrame frame = NextFrame(frame_generator.get(), i);
- frame.set_id(analyzer.OnFrameCaptured(kStreamLabel, frame));
+ frame.set_id(
+ analyzer.OnFrameCaptured(kSenderPeerName, kStreamLabel, frame));
frames_order.push_back(frame.id());
captured_frames.insert({frame.id(), frame});
- analyzer.OnFramePreEncode(frame);
- analyzer.OnFrameEncoded(frame.id(), FakeEncode(frame),
+ analyzer.OnFramePreEncode(kSenderPeerName, frame);
+ analyzer.OnFrameEncoded(kSenderPeerName, frame.id(), FakeEncode(frame),
VideoQualityAnalyzerInterface::EncoderStats());
}
for (size_t i = kMaxFramesInFlightPerStream; i < frames_order.size(); ++i) {
uint16_t frame_id = frames_order.at(i);
VideoFrame received_frame = DeepCopy(captured_frames.at(frame_id));
- analyzer.OnFramePreDecode(received_frame.id(), FakeEncode(received_frame));
- analyzer.OnFrameDecoded(received_frame,
+ analyzer.OnFramePreDecode(kReceiverPeerName, received_frame.id(),
+ FakeEncode(received_frame));
+ analyzer.OnFrameDecoded(kReceiverPeerName, received_frame,
VideoQualityAnalyzerInterface::DecoderStats());
- analyzer.OnFrameRendered(received_frame);
+ analyzer.OnFrameRendered(kReceiverPeerName, received_frame);
}
// Give analyzer some time to process frames on async thread. The computations
@@ -172,21 +178,23 @@
std::vector<uint16_t> frames_order;
for (int i = 0; i < kMaxFramesInFlightPerStream; ++i) {
VideoFrame frame = NextFrame(frame_generator.get(), i);
- frame.set_id(analyzer.OnFrameCaptured(kStreamLabel, frame));
+ frame.set_id(
+ analyzer.OnFrameCaptured(kSenderPeerName, kStreamLabel, frame));
frames_order.push_back(frame.id());
captured_frames.insert({frame.id(), frame});
- analyzer.OnFramePreEncode(frame);
- analyzer.OnFrameEncoded(frame.id(), FakeEncode(frame),
+ analyzer.OnFramePreEncode(kSenderPeerName, frame);
+ analyzer.OnFrameEncoded(kSenderPeerName, frame.id(), FakeEncode(frame),
VideoQualityAnalyzerInterface::EncoderStats());
}
for (size_t i = 1; i < frames_order.size(); i += 2) {
uint16_t frame_id = frames_order.at(i);
VideoFrame received_frame = DeepCopy(captured_frames.at(frame_id));
- analyzer.OnFramePreDecode(received_frame.id(), FakeEncode(received_frame));
- analyzer.OnFrameDecoded(received_frame,
+ analyzer.OnFramePreDecode(kReceiverPeerName, received_frame.id(),
+ FakeEncode(received_frame));
+ analyzer.OnFrameDecoded(kReceiverPeerName, received_frame,
VideoQualityAnalyzerInterface::DecoderStats());
- analyzer.OnFrameRendered(received_frame);
+ analyzer.OnFrameRendered(kReceiverPeerName, received_frame);
}
// Give analyzer some time to process frames on async thread. The computations
diff --git a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc
index d1d1bfa..4488234 100644
--- a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc
+++ b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc
@@ -22,6 +22,7 @@
int max_threads_count) {}
uint16_t ExampleVideoQualityAnalyzer::OnFrameCaptured(
+ absl::string_view peer_name,
const std::string& stream_label,
const webrtc::VideoFrame& frame) {
rtc::CritScope crit(&lock_);
@@ -45,12 +46,14 @@
}
void ExampleVideoQualityAnalyzer::OnFramePreEncode(
+ absl::string_view peer_name,
const webrtc::VideoFrame& frame) {
rtc::CritScope crit(&lock_);
++frames_pre_encoded_;
}
void ExampleVideoQualityAnalyzer::OnFrameEncoded(
+ absl::string_view peer_name,
uint16_t frame_id,
const webrtc::EncodedImage& encoded_image,
const EncoderStats& stats) {
@@ -59,6 +62,7 @@
}
void ExampleVideoQualityAnalyzer::OnFrameDropped(
+ absl::string_view peer_name,
webrtc::EncodedImageCallback::DropReason reason) {
RTC_LOG(INFO) << "Frame dropped by encoder";
rtc::CritScope crit(&lock_);
@@ -66,6 +70,7 @@
}
void ExampleVideoQualityAnalyzer::OnFramePreDecode(
+ absl::string_view peer_name,
uint16_t frame_id,
const webrtc::EncodedImage& encoded_image) {
rtc::CritScope crit(&lock_);
@@ -73,6 +78,7 @@
}
void ExampleVideoQualityAnalyzer::OnFrameDecoded(
+ absl::string_view peer_name,
const webrtc::VideoFrame& frame,
const DecoderStats& stats) {
rtc::CritScope crit(&lock_);
@@ -80,6 +86,7 @@
}
void ExampleVideoQualityAnalyzer::OnFrameRendered(
+ absl::string_view peer_name,
const webrtc::VideoFrame& frame) {
rtc::CritScope crit(&lock_);
frames_in_flight_.erase(frame.id());
@@ -87,13 +94,15 @@
}
void ExampleVideoQualityAnalyzer::OnEncoderError(
+ absl::string_view peer_name,
const webrtc::VideoFrame& frame,
int32_t error_code) {
RTC_LOG(LS_ERROR) << "Failed to encode frame " << frame.id()
<< ". Code: " << error_code;
}
-void ExampleVideoQualityAnalyzer::OnDecoderError(uint16_t frame_id,
+void ExampleVideoQualityAnalyzer::OnDecoderError(absl::string_view peer_name,
+ uint16_t frame_id,
int32_t error_code) {
RTC_LOG(LS_ERROR) << "Failed to decode frame " << frame_id
<< ". Code: " << error_code;
diff --git a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h
index 0d6169f..a4a1104 100644
--- a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h
+++ b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h
@@ -34,20 +34,31 @@
~ExampleVideoQualityAnalyzer() override;
void Start(std::string test_case_name, int max_threads_count) override;
- uint16_t OnFrameCaptured(const std::string& stream_label,
+ uint16_t OnFrameCaptured(absl::string_view peer_name,
+ const std::string& stream_label,
const VideoFrame& frame) override;
- void OnFramePreEncode(const VideoFrame& frame) override;
- void OnFrameEncoded(uint16_t frame_id,
+ void OnFramePreEncode(absl::string_view peer_name,
+ const VideoFrame& frame) override;
+ void OnFrameEncoded(absl::string_view peer_name,
+ uint16_t frame_id,
const EncodedImage& encoded_image,
const EncoderStats& stats) override;
- void OnFrameDropped(EncodedImageCallback::DropReason reason) override;
- void OnFramePreDecode(uint16_t frame_id,
+ void OnFrameDropped(absl::string_view peer_name,
+ EncodedImageCallback::DropReason reason) override;
+ void OnFramePreDecode(absl::string_view peer_name,
+ uint16_t frame_id,
const EncodedImage& encoded_image) override;
- void OnFrameDecoded(const VideoFrame& frame,
+ void OnFrameDecoded(absl::string_view peer_name,
+ const VideoFrame& frame,
const DecoderStats& stats) override;
- void OnFrameRendered(const VideoFrame& frame) override;
- void OnEncoderError(const VideoFrame& frame, int32_t error_code) override;
- void OnDecoderError(uint16_t frame_id, int32_t error_code) override;
+ void OnFrameRendered(absl::string_view peer_name,
+ const VideoFrame& frame) override;
+ void OnEncoderError(absl::string_view peer_name,
+ const VideoFrame& frame,
+ int32_t error_code) override;
+ void OnDecoderError(absl::string_view peer_name,
+ uint16_t frame_id,
+ int32_t error_code) override;
void Stop() override;
std::string GetStreamLabel(uint16_t frame_id) override;
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc
index 228ab8a..9e81c87 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc
@@ -15,6 +15,7 @@
#include <memory>
#include <utility>
+#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/video/i420_buffer.h"
#include "modules/video_coding/include/video_error_codes.h"
@@ -26,10 +27,12 @@
QualityAnalyzingVideoDecoder::QualityAnalyzingVideoDecoder(
int id,
+ absl::string_view peer_name,
std::unique_ptr<VideoDecoder> delegate,
EncodedImageDataExtractor* extractor,
VideoQualityAnalyzerInterface* analyzer)
: id_(id),
+ peer_name_(peer_name),
implementation_name_("AnalyzingDecoder-" +
std::string(delegate->ImplementationName())),
delegate_(std::move(delegate)),
@@ -87,7 +90,7 @@
// We can safely dereference |origin_image|, because it can be removed from
// the map only after |delegate_| Decode method will be invoked. Image will be
// removed inside DecodedImageCallback, which can be done on separate thread.
- analyzer_->OnFramePreDecode(out.id, *origin_image);
+ analyzer_->OnFramePreDecode(peer_name_, out.id, *origin_image);
int32_t result =
delegate_->Decode(*origin_image, missing_frames, render_time_ms);
if (result != WEBRTC_VIDEO_CODEC_OK) {
@@ -97,7 +100,7 @@
timestamp_to_frame_id_.erase(input_image.Timestamp());
decoding_images_.erase(out.id);
}
- analyzer_->OnDecoderError(out.id, result);
+ analyzer_->OnDecoderError(peer_name_, out.id, result);
}
return result;
}
@@ -224,15 +227,17 @@
frame->set_id(frame_id);
VideoQualityAnalyzerInterface::DecoderStats stats;
stats.decode_time_ms = decode_time_ms;
- analyzer_->OnFrameDecoded(*frame, stats);
+ analyzer_->OnFrameDecoded(peer_name_, *frame, stats);
}
QualityAnalyzingVideoDecoderFactory::QualityAnalyzingVideoDecoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoDecoderFactory> delegate,
IdGenerator<int>* id_generator,
EncodedImageDataExtractor* extractor,
VideoQualityAnalyzerInterface* analyzer)
- : delegate_(std::move(delegate)),
+ : peer_name_(peer_name),
+ delegate_(std::move(delegate)),
id_generator_(id_generator),
extractor_(extractor),
analyzer_(analyzer) {}
@@ -249,7 +254,8 @@
const SdpVideoFormat& format) {
std::unique_ptr<VideoDecoder> decoder = delegate_->CreateVideoDecoder(format);
return std::make_unique<QualityAnalyzingVideoDecoder>(
- id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
+ id_generator_->GetNextId(), peer_name_, std::move(decoder), extractor_,
+ analyzer_);
}
std::unique_ptr<VideoDecoder>
@@ -259,7 +265,8 @@
std::unique_ptr<VideoDecoder> decoder =
delegate_->LegacyCreateVideoDecoder(format, receive_stream_id);
return std::make_unique<QualityAnalyzingVideoDecoder>(
- id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
+ id_generator_->GetNextId(), peer_name_, std::move(decoder), extractor_,
+ analyzer_);
}
} // namespace webrtc_pc_e2e
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h
index 5cbc882..29fff18 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h
@@ -16,6 +16,7 @@
#include <string>
#include <vector>
+#include "absl/strings/string_view.h"
#include "api/test/video_quality_analyzer_interface.h"
#include "api/video/encoded_image.h"
#include "api/video/video_frame.h"
@@ -53,6 +54,7 @@
// be used to distinguish all encoders and decoders inside
// EncodedImageDataInjector and EncodedImageIdExtracor.
QualityAnalyzingVideoDecoder(int id,
+ absl::string_view peer_name,
std::unique_ptr<VideoDecoder> delegate,
EncodedImageDataExtractor* extractor,
VideoQualityAnalyzerInterface* analyzer);
@@ -104,6 +106,7 @@
absl::optional<uint8_t> qp);
const int id_;
+ const std::string peer_name_;
const std::string implementation_name_;
std::unique_ptr<VideoDecoder> delegate_;
EncodedImageDataExtractor* const extractor_;
@@ -129,6 +132,7 @@
class QualityAnalyzingVideoDecoderFactory : public VideoDecoderFactory {
public:
QualityAnalyzingVideoDecoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoDecoderFactory> delegate,
IdGenerator<int>* id_generator,
EncodedImageDataExtractor* extractor,
@@ -144,6 +148,7 @@
const std::string& receive_stream_id) override;
private:
+ const std::string peer_name_;
std::unique_ptr<VideoDecoderFactory> delegate_;
IdGenerator<int>* const id_generator_;
EncodedImageDataExtractor* const extractor_;
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
index 2e7b8f4..4d04a2c 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
@@ -14,6 +14,7 @@
#include <memory>
#include <utility>
+#include "absl/strings/string_view.h"
#include "api/video/video_codec_type.h"
#include "api/video_codecs/video_encoder.h"
#include "modules/video_coding/include/video_error_codes.h"
@@ -54,12 +55,14 @@
QualityAnalyzingVideoEncoder::QualityAnalyzingVideoEncoder(
int id,
+ absl::string_view peer_name,
std::unique_ptr<VideoEncoder> delegate,
double bitrate_multiplier,
std::map<std::string, absl::optional<int>> stream_required_spatial_index,
EncodedImageDataInjector* injector,
VideoQualityAnalyzerInterface* analyzer)
: id_(id),
+ peer_name_(peer_name),
delegate_(std::move(delegate)),
bitrate_multiplier_(bitrate_multiplier),
stream_required_spatial_index_(std::move(stream_required_spatial_index)),
@@ -134,7 +137,7 @@
// images from encoder. So it should be a bug in setup on in the encoder.
RTC_DCHECK_LT(timestamp_to_frame_id_list_.size(), kMaxFrameInPipelineCount);
}
- analyzer_->OnFramePreEncode(frame);
+ analyzer_->OnFramePreEncode(peer_name_, frame);
int32_t result = delegate_->Encode(frame, frame_types);
if (result != WEBRTC_VIDEO_CODEC_OK) {
// If origin encoder failed, then cleanup data for this frame.
@@ -152,7 +155,7 @@
}
}
}
- analyzer_->OnEncoderError(frame, result);
+ analyzer_->OnEncoderError(peer_name_, frame, result);
}
return result;
}
@@ -277,7 +280,7 @@
// not discarded layers have to be passed.
VideoQualityAnalyzerInterface::EncoderStats stats;
stats.target_encode_bitrate = target_encode_bitrate;
- analyzer_->OnFrameEncoded(frame_id, encoded_image, stats);
+ analyzer_->OnFrameEncoded(peer_name_, frame_id, encoded_image, stats);
}
// Image data injector injects frame id and discard flag into provided
@@ -298,7 +301,7 @@
void QualityAnalyzingVideoEncoder::OnDroppedFrame(
EncodedImageCallback::DropReason reason) {
rtc::CritScope crit(&lock_);
- analyzer_->OnFrameDropped(reason);
+ analyzer_->OnFrameDropped(peer_name_, reason);
RTC_DCHECK(delegate_callback_);
delegate_callback_->OnDroppedFrame(reason);
}
@@ -348,13 +351,15 @@
}
QualityAnalyzingVideoEncoderFactory::QualityAnalyzingVideoEncoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoEncoderFactory> delegate,
double bitrate_multiplier,
std::map<std::string, absl::optional<int>> stream_required_spatial_index,
IdGenerator<int>* id_generator,
EncodedImageDataInjector* injector,
VideoQualityAnalyzerInterface* analyzer)
- : delegate_(std::move(delegate)),
+ : peer_name_(peer_name),
+ delegate_(std::move(delegate)),
bitrate_multiplier_(bitrate_multiplier),
stream_required_spatial_index_(std::move(stream_required_spatial_index)),
id_generator_(id_generator),
@@ -378,9 +383,9 @@
QualityAnalyzingVideoEncoderFactory::CreateVideoEncoder(
const SdpVideoFormat& format) {
return std::make_unique<QualityAnalyzingVideoEncoder>(
- id_generator_->GetNextId(), delegate_->CreateVideoEncoder(format),
- bitrate_multiplier_, stream_required_spatial_index_, injector_,
- analyzer_);
+ id_generator_->GetNextId(), peer_name_,
+ delegate_->CreateVideoEncoder(format), bitrate_multiplier_,
+ stream_required_spatial_index_, injector_, analyzer_);
}
} // namespace webrtc_pc_e2e
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
index 3307dc7..fe9e6bb 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
@@ -16,6 +16,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/string_view.h"
#include "api/test/video_quality_analyzer_interface.h"
#include "api/video/video_frame.h"
#include "api/video_codecs/sdp_video_format.h"
@@ -59,6 +60,7 @@
// EncodedImageDataInjector and EncodedImageIdExtracor.
QualityAnalyzingVideoEncoder(
int id,
+ absl::string_view peer_name,
std::unique_ptr<VideoEncoder> delegate,
double bitrate_multiplier,
std::map<std::string, absl::optional<int>> stream_required_spatial_index,
@@ -139,6 +141,7 @@
RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
const int id_;
+ const std::string peer_name_;
std::unique_ptr<VideoEncoder> delegate_;
const double bitrate_multiplier_;
// Contains mapping from stream label to optional spatial index.
@@ -170,6 +173,7 @@
class QualityAnalyzingVideoEncoderFactory : public VideoEncoderFactory {
public:
QualityAnalyzingVideoEncoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoEncoderFactory> delegate,
double bitrate_multiplier,
std::map<std::string, absl::optional<int>> stream_required_spatial_index,
@@ -186,6 +190,7 @@
const SdpVideoFormat& format) override;
private:
+ const std::string peer_name_;
std::unique_ptr<VideoEncoderFactory> delegate_;
const double bitrate_multiplier_;
std::map<std::string, absl::optional<int>> stream_required_spatial_index_;
diff --git a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc
index 0741884..7410954 100644
--- a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc
+++ b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc
@@ -14,6 +14,7 @@
#include <vector>
#include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
#include "test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h"
#include "test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h"
#include "test/pc/e2e/analyzer/video/simulcast_dummy_buffer_helper.h"
@@ -43,10 +44,12 @@
: public test::TestVideoCapturer::FramePreprocessor {
public:
AnalyzingFramePreprocessor(
- std::string stream_label,
+ absl::string_view peer_name,
+ absl::string_view stream_label,
VideoQualityAnalyzerInterface* analyzer,
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks)
- : stream_label_(std::move(stream_label)),
+ : peer_name_(peer_name),
+ stream_label_(stream_label),
analyzer_(analyzer),
sinks_(std::move(sinks)) {}
~AnalyzingFramePreprocessor() override = default;
@@ -54,7 +57,8 @@
VideoFrame Preprocess(const VideoFrame& source_frame) override {
// Copy VideoFrame to be able to set id on it.
VideoFrame frame = source_frame;
- uint16_t frame_id = analyzer_->OnFrameCaptured(stream_label_, frame);
+ uint16_t frame_id =
+ analyzer_->OnFrameCaptured(peer_name_, stream_label_, frame);
frame.set_id(frame_id);
for (auto& sink : sinks_) {
@@ -64,6 +68,7 @@
}
private:
+ const std::string peer_name_;
const std::string stream_label_;
VideoQualityAnalyzerInterface* const analyzer_;
const std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>
@@ -88,26 +93,29 @@
std::unique_ptr<VideoEncoderFactory>
VideoQualityAnalyzerInjectionHelper::WrapVideoEncoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoEncoderFactory> delegate,
double bitrate_multiplier,
std::map<std::string, absl::optional<int>> stream_required_spatial_index)
const {
return std::make_unique<QualityAnalyzingVideoEncoderFactory>(
- std::move(delegate), bitrate_multiplier,
+ peer_name, std::move(delegate), bitrate_multiplier,
std::move(stream_required_spatial_index),
encoding_entities_id_generator_.get(), injector_, analyzer_.get());
}
std::unique_ptr<VideoDecoderFactory>
VideoQualityAnalyzerInjectionHelper::WrapVideoDecoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoDecoderFactory> delegate) const {
return std::make_unique<QualityAnalyzingVideoDecoderFactory>(
- std::move(delegate), encoding_entities_id_generator_.get(), extractor_,
- analyzer_.get());
+ peer_name, std::move(delegate), encoding_entities_id_generator_.get(),
+ extractor_, analyzer_.get());
}
std::unique_ptr<test::TestVideoCapturer::FramePreprocessor>
VideoQualityAnalyzerInjectionHelper::CreateFramePreprocessor(
+ absl::string_view peer_name,
const VideoConfig& config) {
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks;
test::VideoFrameWriter* writer =
@@ -125,12 +133,14 @@
known_video_configs_.insert({*config.stream_label, config});
}
return std::make_unique<AnalyzingFramePreprocessor>(
- std::move(*config.stream_label), analyzer_.get(), std::move(sinks));
+ peer_name, std::move(*config.stream_label), analyzer_.get(),
+ std::move(sinks));
}
std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>
-VideoQualityAnalyzerInjectionHelper::CreateVideoSink() {
- return std::make_unique<AnalyzingVideoSink>(this);
+VideoQualityAnalyzerInjectionHelper::CreateVideoSink(
+ absl::string_view peer_name) {
+ return std::make_unique<AnalyzingVideoSink>(peer_name, this);
}
void VideoQualityAnalyzerInjectionHelper::Start(std::string test_case_name,
@@ -169,12 +179,13 @@
return out;
}
-void VideoQualityAnalyzerInjectionHelper::OnFrame(const VideoFrame& frame) {
+void VideoQualityAnalyzerInjectionHelper::OnFrame(absl::string_view peer_name,
+ const VideoFrame& frame) {
if (IsDummyFrameBuffer(frame.video_frame_buffer()->ToI420())) {
// This is dummy frame, so we don't need to process it further.
return;
}
- analyzer_->OnFrameRendered(frame);
+ analyzer_->OnFrameRendered(peer_name, frame);
std::string stream_label = analyzer_->GetStreamLabel(frame.id());
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>* sinks =
PopulateSinks(stream_label);
diff --git a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h
index a0daa9f..3dfc0af 100644
--- a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h
+++ b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h
@@ -15,6 +15,7 @@
#include <memory>
#include <string>
+#include "absl/strings/string_view.h"
#include "api/test/peerconnection_quality_test_fixture.h"
#include "api/test/stats_observer_interface.h"
#include "api/test/video_quality_analyzer_interface.h"
@@ -46,6 +47,7 @@
// Wraps video encoder factory to give video quality analyzer access to frames
// before encoding and encoded images after.
std::unique_ptr<VideoEncoderFactory> WrapVideoEncoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoEncoderFactory> delegate,
double bitrate_multiplier,
std::map<std::string, absl::optional<int>> stream_required_spatial_index)
@@ -53,18 +55,24 @@
// Wraps video decoder factory to give video quality analyzer access to
// received encoded images and frames, that were decoded from them.
std::unique_ptr<VideoDecoderFactory> WrapVideoDecoderFactory(
+ absl::string_view peer_name,
std::unique_ptr<VideoDecoderFactory> delegate) const;
// Creates VideoFrame preprocessor, that will allow video quality analyzer to
// get access to the captured frames. If provided config also specifies
// |input_dump_file_name|, video will be written into that file.
std::unique_ptr<test::TestVideoCapturer::FramePreprocessor>
- CreateFramePreprocessor(const VideoConfig& config);
+ CreateFramePreprocessor(absl::string_view peer_name,
+ const VideoConfig& config);
// Creates sink, that will allow video quality analyzer to get access to
// the rendered frames. If corresponding video track has
// |output_dump_file_name| in its VideoConfig, then video also will be written
// into that file.
- std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> CreateVideoSink();
+ std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> CreateVideoSink(
+ absl::string_view peer_name);
+ std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> CreateVideoSink() {
+ return CreateVideoSink("unknown");
+ }
void Start(std::string test_case_name, int max_threads_count);
@@ -80,20 +88,24 @@
private:
class AnalyzingVideoSink final : public rtc::VideoSinkInterface<VideoFrame> {
public:
- explicit AnalyzingVideoSink(VideoQualityAnalyzerInjectionHelper* helper)
- : helper_(helper) {}
+ explicit AnalyzingVideoSink(absl::string_view peer_name,
+ VideoQualityAnalyzerInjectionHelper* helper)
+ : peer_name_(peer_name), helper_(helper) {}
~AnalyzingVideoSink() override = default;
- void OnFrame(const VideoFrame& frame) override { helper_->OnFrame(frame); }
+ void OnFrame(const VideoFrame& frame) override {
+ helper_->OnFrame(peer_name_, frame);
+ }
private:
+ const std::string peer_name_;
VideoQualityAnalyzerInjectionHelper* const helper_;
};
test::VideoFrameWriter* MaybeCreateVideoWriter(
absl::optional<std::string> file_name,
const PeerConnectionE2EQualityTestFixture::VideoConfig& config);
- void OnFrame(const VideoFrame& frame);
+ void OnFrame(absl::string_view peer_name, const VideoFrame& frame);
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>*
PopulateSinks(const std::string& stream_label);
diff --git a/test/pc/e2e/media/media_helper.cc b/test/pc/e2e/media/media_helper.cc
index d3fa6ff..d1c2783 100644
--- a/test/pc/e2e/media/media_helper.cc
+++ b/test/pc/e2e/media/media_helper.cc
@@ -58,7 +58,7 @@
std::unique_ptr<test::TestVideoCapturer> capturer = CreateVideoCapturer(
video_config, peer->ReleaseVideoSource(i),
video_quality_analyzer_injection_helper_->CreateFramePreprocessor(
- video_config));
+ params->name.value(), video_config));
bool is_screencast =
video_config.content_hint == VideoTrackInterface::ContentHint::kText ||
video_config.content_hint ==
diff --git a/test/pc/e2e/peer_connection_quality_test.cc b/test/pc/e2e/peer_connection_quality_test.cc
index 17104a9..cea4955 100644
--- a/test/pc/e2e/peer_connection_quality_test.cc
+++ b/test/pc/e2e/peer_connection_quality_test.cc
@@ -14,6 +14,7 @@
#include <set>
#include <utility>
+#include "absl/strings/string_view.h"
#include "api/jsep.h"
#include "api/media_stream_interface.h"
#include "api/peer_connection_interface.h"
@@ -205,18 +206,21 @@
RemotePeerAudioConfig::Create(bob_configurer->params()->audio_config);
absl::optional<RemotePeerAudioConfig> bob_remote_audio_config =
RemotePeerAudioConfig::Create(alice_configurer->params()->audio_config);
- // Copy Alice and Bob video configs to correctly pass them into lambdas.
+ // Copy Alice and Bob video configs and names to correctly pass them into
+ // lambdas.
std::vector<VideoConfig> alice_video_configs =
alice_configurer->params()->video_configs;
+ std::string alice_name = alice_configurer->params()->name.value();
std::vector<VideoConfig> bob_video_configs =
bob_configurer->params()->video_configs;
+ std::string bob_name = bob_configurer->params()->name.value();
alice_ = TestPeerFactory::CreateTestPeer(
std::move(alice_configurer),
std::make_unique<FixturePeerConnectionObserver>(
- [this, bob_video_configs](
+ [this, bob_video_configs, alice_name](
rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
- OnTrackCallback(transceiver, bob_video_configs);
+ OnTrackCallback(alice_name, transceiver, bob_video_configs);
},
[this]() { StartVideo(alice_video_sources_); }),
video_quality_analyzer_injection_helper_.get(), signaling_thread.get(),
@@ -225,9 +229,9 @@
bob_ = TestPeerFactory::CreateTestPeer(
std::move(bob_configurer),
std::make_unique<FixturePeerConnectionObserver>(
- [this, alice_video_configs](
- rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
- OnTrackCallback(transceiver, alice_video_configs);
+ [this, alice_video_configs,
+ bob_name](rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+ OnTrackCallback(bob_name, transceiver, alice_video_configs);
},
[this]() { StartVideo(bob_video_sources_); }),
video_quality_analyzer_injection_helper_.get(), signaling_thread.get(),
@@ -371,6 +375,7 @@
}
void PeerConnectionE2EQualityTest::OnTrackCallback(
+ absl::string_view peer_name,
rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
std::vector<VideoConfig> remote_video_configs) {
const rtc::scoped_refptr<MediaStreamTrackInterface>& track =
@@ -387,7 +392,7 @@
// track->kind() is kVideoKind.
auto* video_track = static_cast<VideoTrackInterface*>(track.get());
std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> video_sink =
- video_quality_analyzer_injection_helper_->CreateVideoSink();
+ video_quality_analyzer_injection_helper_->CreateVideoSink(peer_name);
video_track->AddOrUpdateSink(video_sink.get(), rtc::VideoSinkWants());
output_video_sinks_.push_back(std::move(video_sink));
}
diff --git a/test/pc/e2e/peer_connection_quality_test.h b/test/pc/e2e/peer_connection_quality_test.h
index 2eb7e70..b302e5c 100644
--- a/test/pc/e2e/peer_connection_quality_test.h
+++ b/test/pc/e2e/peer_connection_quality_test.h
@@ -15,6 +15,7 @@
#include <string>
#include <vector>
+#include "absl/strings/string_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/audio_quality_analyzer_interface.h"
#include "api/test/peerconnection_quality_test_fixture.h"
@@ -80,7 +81,8 @@
// For some functionality some field trials have to be enabled, so we will
// enable them here.
void SetupRequiredFieldTrials(const RunParams& run_params);
- void OnTrackCallback(rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
+ void OnTrackCallback(absl::string_view peer_name,
+ rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
std::vector<VideoConfig> remote_video_configs);
// Have to be run on the signaling thread.
void SetupCallOnSignalingThread(const RunParams& run_params);
diff --git a/test/pc/e2e/test_peer_factory.cc b/test/pc/e2e/test_peer_factory.cc
index 455337e..e845dc7 100644
--- a/test/pc/e2e/test_peer_factory.cc
+++ b/test/pc/e2e/test_peer_factory.cc
@@ -12,6 +12,7 @@
#include <utility>
#include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/video_codecs/builtin_video_decoder_factory.h"
#include "api/video_codecs/builtin_video_encoder_factory.h"
@@ -172,6 +173,7 @@
}
void WrapVideoEncoderFactory(
+ absl::string_view peer_name,
double bitrate_multiplier,
std::map<std::string, absl::optional<int>> stream_required_spatial_index,
PeerConnectionFactoryComponents* pcf_dependencies,
@@ -184,11 +186,12 @@
}
pcf_dependencies->video_encoder_factory =
video_analyzer_helper->WrapVideoEncoderFactory(
- std::move(video_encoder_factory), bitrate_multiplier,
+ peer_name, std::move(video_encoder_factory), bitrate_multiplier,
std::move(stream_required_spatial_index));
}
void WrapVideoDecoderFactory(
+ absl::string_view peer_name,
PeerConnectionFactoryComponents* pcf_dependencies,
VideoQualityAnalyzerInjectionHelper* video_analyzer_helper) {
std::unique_ptr<VideoDecoderFactory> video_decoder_factory;
@@ -199,7 +202,7 @@
}
pcf_dependencies->video_decoder_factory =
video_analyzer_helper->WrapVideoDecoderFactory(
- std::move(video_decoder_factory));
+ peer_name, std::move(video_decoder_factory));
}
// Creates PeerConnectionFactoryDependencies objects, providing entities
@@ -309,10 +312,11 @@
params->audio_config, remote_audio_config, echo_emulation_config,
components->pcf_dependencies->task_queue_factory.get());
WrapVideoEncoderFactory(
- bitrate_multiplier,
+ params->name.value(), bitrate_multiplier,
CalculateRequiredSpatialIndexPerStream(params->video_configs),
components->pcf_dependencies.get(), video_analyzer_helper);
- WrapVideoDecoderFactory(components->pcf_dependencies.get(),
+ WrapVideoDecoderFactory(params->name.value(),
+ components->pcf_dependencies.get(),
video_analyzer_helper);
std::unique_ptr<cricket::MediaEngineInterface> media_engine =
CreateMediaEngine(components->pcf_dependencies.get(), audio_device_module,
