zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Relax video_codec parameter for RtpVideoStreamReceiver2::AddReceiveCodec

Browse Source 
Instead of requiring huge VideoCodec struct, pass single member from it

Bug: webrtc:13045
Change-Id: I46a3c24cd2c9c3a450f897ed014cb95d7dfcc841
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/228382
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34704}
This commit is contained in:
Danil Chapovalov
2021-08-10 16:57:56 +02:00
committed by WebRTC LUCI CQ
parent 320c57b7c6
commit 5653c95ca2
4 changed files with 22 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
video/rtp_video_stream_receiver2.cc
View File

@ -20,6 +20,7 @@
#include "absl/base/macros.h" #include "absl/base/macros.h"
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/video/video_codec_type.h"
#include "media/base/media_constants.h" #include "media/base/media_constants.h"
#include "modules/pacing/packet_router.h" #include "modules/pacing/packet_router.h"
#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" #include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
@ -324,7 +325,7 @@ RtpVideoStreamReceiver2::~RtpVideoStreamReceiver2() {
void RtpVideoStreamReceiver2::AddReceiveCodec( void RtpVideoStreamReceiver2::AddReceiveCodec(
uint8_t payload_type, uint8_t payload_type,
const VideoCodec& video_codec, VideoCodecType video_codec,
const std::map<std::string, std::string>& codec_params, const std::map<std::string, std::string>& codec_params,
bool raw_payload) { bool raw_payload) {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
@ -333,9 +334,8 @@ void RtpVideoStreamReceiver2::AddReceiveCodec(
packet_buffer_.ForceSpsPpsIdrIsH264Keyframe(); packet_buffer_.ForceSpsPpsIdrIsH264Keyframe();
} }
payload_type_map_.emplace( payload_type_map_.emplace(
payload_type, raw_payload payload_type, raw_payload ? std::make_unique<VideoRtpDepacketizerRaw>()
? std::make_unique<VideoRtpDepacketizerRaw>() : CreateVideoRtpDepacketizer(video_codec));
: CreateVideoRtpDepacketizer(video_codec.codecType));
pt_codec_params_.emplace(payload_type, codec_params); pt_codec_params_.emplace(payload_type, codec_params);
} }

4
video/rtp_video_stream_receiver2.h
View File

@ -21,7 +21,7 @@
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/units/timestamp.h" #include "api/units/timestamp.h"
#include "api/video/color_space.h" #include "api/video/color_space.h"
#include "api/video_codecs/video_codec.h" #include "api/video/video_codec_type.h"
#include "call/rtp_packet_sink_interface.h" #include "call/rtp_packet_sink_interface.h"
#include "call/syncable.h" #include "call/syncable.h"
#include "call/video_receive_stream.h" #include "call/video_receive_stream.h"
@ -101,7 +101,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
~RtpVideoStreamReceiver2() override; ~RtpVideoStreamReceiver2() override;
void AddReceiveCodec(uint8_t payload_type, void AddReceiveCodec(uint8_t payload_type,
const VideoCodec& video_codec, VideoCodecType video_codec,
const std::map<std::string, std::string>& codec_params, const std::map<std::string, std::string>& codec_params,
bool raw_payload); bool raw_payload);

33
video/rtp_video_stream_receiver2_unittest.cc
View File

@ -163,9 +163,8 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test,
nullptr, &nack_periodic_processor_, &mock_nack_sender_, nullptr, &nack_periodic_processor_, &mock_nack_sender_,
&mock_key_frame_request_sender_, &mock_on_complete_frame_callback_, &mock_key_frame_request_sender_, &mock_on_complete_frame_callback_,
nullptr, nullptr); nullptr, nullptr);
VideoCodec codec; rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType,
codec.codecType = kVideoCodecGeneric; kVideoCodecGeneric, {},
rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, codec, {},
/*raw_payload=*/false); /*raw_payload=*/false);
} }
@ -307,10 +306,8 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
received_packet_generator.SetColorSpace(kColorSpace); received_packet_generator.SetColorSpace(kColorSpace);
// Prepare the receiver for VP9. // Prepare the receiver for VP9.
VideoCodec codec;
codec.codecType = kVideoCodecVP9;
std::map<std::string, std::string> codec_params; std::map<std::string, std::string> codec_params;
rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, codec, rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, kVideoCodecVP9,
codec_params, codec_params,
/*raw_payload=*/false); /*raw_payload=*/false);
@ -563,13 +560,13 @@ TEST_P(RtpVideoStreamReceiver2TestH264, InBandSpsPps) {
TEST_P(RtpVideoStreamReceiver2TestH264, OutOfBandFmtpSpsPps) { TEST_P(RtpVideoStreamReceiver2TestH264, OutOfBandFmtpSpsPps) {
constexpr int kPayloadType = 99; constexpr int kPayloadType = 99;
VideoCodec codec;
std::map<std::string, std::string> codec_params; std::map<std::string, std::string> codec_params;
// Example parameter sets from https://tools.ietf.org/html/rfc3984#section-8.2 // Example parameter sets from https://tools.ietf.org/html/rfc3984#section-8.2
// . // .
codec_params.insert( codec_params.insert(
{cricket::kH264FmtpSpropParameterSets, "Z0IACpZTBYmI,aMljiA=="}); {cricket::kH264FmtpSpropParameterSets, "Z0IACpZTBYmI,aMljiA=="});
rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, codec, codec_params, rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, kVideoCodecH264,
codec_params,
/*raw_payload=*/false); /*raw_payload=*/false);
const uint8_t binary_sps[] = {0x67, 0x42, 0x00, 0x0a, 0x96, const uint8_t binary_sps[] = {0x67, 0x42, 0x00, 0x0a, 0x96,
0x53, 0x05, 0x89, 0x88}; 0x53, 0x05, 0x89, 0x88};
@ -604,13 +601,13 @@ TEST_P(RtpVideoStreamReceiver2TestH264, OutOfBandFmtpSpsPps) {
TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) { TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
constexpr int kPayloadType = 99; constexpr int kPayloadType = 99;
VideoCodec codec;
std::map<std::string, std::string> codec_params; std::map<std::string, std::string> codec_params;
if (GetParam() == if (GetParam() ==
"") { // Forcing can be done either with field trial or codec_params. "") { // Forcing can be done either with field trial or codec_params.
codec_params.insert({cricket::kH264FmtpSpsPpsIdrInKeyframe, ""}); codec_params.insert({cricket::kH264FmtpSpsPpsIdrInKeyframe, ""});
} }
rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, codec, codec_params, rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, kVideoCodecH264,
codec_params,
/*raw_payload=*/false); /*raw_payload=*/false);
rtc::CopyOnWriteBuffer sps_data; rtc::CopyOnWriteBuffer sps_data;
RtpPacketReceived rtp_packet; RtpPacketReceived rtp_packet;
@ -881,8 +878,8 @@ TEST_F(RtpVideoStreamReceiver2Test, ParseGenericDescriptorRawPayload) {
const std::vector<uint8_t> data = {0, 1, 2, 3, 4}; const std::vector<uint8_t> data = {0, 1, 2, 3, 4};
const int kRawPayloadType = 123; const int kRawPayloadType = 123;
VideoCodec codec; rtp_video_stream_receiver_->AddReceiveCodec(kRawPayloadType,
rtp_video_stream_receiver_->AddReceiveCodec(kRawPayloadType, codec, {}, kVideoCodecGeneric, {},
/*raw_payload=*/true); /*raw_payload=*/true);
rtp_video_stream_receiver_->StartReceive(); rtp_video_stream_receiver_->StartReceive();
@ -913,8 +910,8 @@ TEST_F(RtpVideoStreamReceiver2Test, UnwrapsFrameId) {
const std::vector<uint8_t> data = {0, 1, 2, 3, 4}; const std::vector<uint8_t> data = {0, 1, 2, 3, 4};
const int kPayloadType = 123; const int kPayloadType = 123;
VideoCodec codec; rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, kVideoCodecGeneric,
rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, codec, {}, {},
/*raw_payload=*/true); /*raw_payload=*/true);
rtp_video_stream_receiver_->StartReceive(); rtp_video_stream_receiver_->StartReceive();
RtpHeaderExtensionMap extension_map; RtpHeaderExtensionMap extension_map;
@ -959,8 +956,8 @@ class RtpVideoStreamReceiver2DependencyDescriptorTest
: public RtpVideoStreamReceiver2Test { : public RtpVideoStreamReceiver2Test {
public: public:
RtpVideoStreamReceiver2DependencyDescriptorTest() { RtpVideoStreamReceiver2DependencyDescriptorTest() {
VideoCodec codec; rtp_video_stream_receiver_->AddReceiveCodec(payload_type_,
rtp_video_stream_receiver_->AddReceiveCodec(payload_type_, codec, {}, kVideoCodecGeneric, {},
/*raw_payload=*/true); /*raw_payload=*/true);
extension_map_.Register<RtpDependencyDescriptorExtension>(7); extension_map_.Register<RtpDependencyDescriptorExtension>(7);
rtp_video_stream_receiver_->StartReceive(); rtp_video_stream_receiver_->StartReceive();
@ -1124,9 +1121,7 @@ TEST_F(RtpVideoStreamReceiver2Test, TransformFrame) {
nullptr, nullptr, &config_, rtp_receive_statistics_.get(), nullptr, nullptr, nullptr, &config_, rtp_receive_statistics_.get(), nullptr,
nullptr, &nack_periodic_processor_, &mock_nack_sender_, nullptr, nullptr, &nack_periodic_processor_, &mock_nack_sender_, nullptr,
&mock_on_complete_frame_callback_, nullptr, mock_frame_transformer); &mock_on_complete_frame_callback_, nullptr, mock_frame_transformer);
VideoCodec video_codec; receiver->AddReceiveCodec(kPayloadType, kVideoCodecGeneric, {},
video_codec.codecType = kVideoCodecGeneric;
receiver->AddReceiveCodec(kPayloadType, video_codec, {},
/*raw_payload=*/false); /*raw_payload=*/false);
RtpPacketReceived rtp_packet; RtpPacketReceived rtp_packet;

4
video/video_receive_stream2.cc
View File

@ -388,8 +388,8 @@ void VideoReceiveStream2::Start() {
// TODO(bugs.webrtc.org/11993): Make this call on the network thread. // TODO(bugs.webrtc.org/11993): Make this call on the network thread.
RTC_DCHECK_RUN_ON(&packet_sequence_checker_); RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
rtp_video_stream_receiver_.AddReceiveCodec( rtp_video_stream_receiver_.AddReceiveCodec(
decoder.payload_type, codec, decoder.video_format.parameters, decoder.payload_type, codec.codecType,
raw_payload); decoder.video_format.parameters, raw_payload);
} }
RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec( RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
decoder.payload_type, &codec, num_cpu_cores_)); decoder.payload_type, &codec, num_cpu_cores_));