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

Use SdpVideoFormat in VideoReceiveStream::Decoder

Browse Source 
Replaces payload_name and codec_params.

Tbr: srte@webrtc.org
Bug: webrtc:9106
Change-Id: Ib45c501c6eb41e92fbb24ab00ada18bf10be42ed
Reviewed-on: https://webrtc-review.googlesource.com/98161
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24691}
This commit is contained in:
Niels Möller 2018-09-11 15:56:04 +02:00 committed by Commit Bot
parent c7fff58d1e
commit cb7e1d2edb
18 changed files with 46 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
call/bitrate_estimator_tests.cc
View File

@ -187,7 +187,8 @@ class BitrateEstimatorTest : public test::CallTest {
VideoReceiveStream::Decoder decoder; VideoReceiveStream::Decoder decoder;
decoder.decoder = &fake_decoder_; decoder.decoder = &fake_decoder_;
decoder.payload_type = test_->GetVideoSendConfig()->rtp.payload_type; decoder.payload_type = test_->GetVideoSendConfig()->rtp.payload_type;
decoder.payload_name = test_->GetVideoSendConfig()->rtp.payload_name; decoder.video_format =
SdpVideoFormat(test_->GetVideoSendConfig()->rtp.payload_name);
test_->receive_config_.decoders.clear(); test_->receive_config_.decoders.clear();
test_->receive_config_.decoders.push_back(decoder); test_->receive_config_.decoders.push_back(decoder);
test_->receive_config_.rtp.remote_ssrc = test_->receive_config_.rtp.remote_ssrc =

2
call/call.cc
View File

@ -114,7 +114,7 @@ std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
for (const auto& d : config.decoders) { for (const auto& d : config.decoders) {
const int* search = const int* search =
FindKeyByValue(config.rtp.rtx_associated_payload_types, d.payload_type); FindKeyByValue(config.rtp.rtx_associated_payload_types, d.payload_type);
rtclog_config->codecs.emplace_back(d.payload_name, d.payload_type, rtclog_config->codecs.emplace_back(d.video_format.name, d.payload_type,
search ? *search : 0); search ? *search : 0);
} }
return rtclog_config; return rtclog_config;

3
call/rampup_tests.cc
View File

@ -208,7 +208,8 @@ void RampUpTester::ModifyVideoConfigs(
recv_config.rtp.extensions = send_config->rtp.extensions; recv_config.rtp.extensions = send_config->rtp.extensions;
recv_config.decoders.reserve(1); recv_config.decoders.reserve(1);
recv_config.decoders[0].payload_type = send_config->rtp.payload_type; recv_config.decoders[0].payload_type = send_config->rtp.payload_type;
recv_config.decoders[0].payload_name = send_config->rtp.payload_name; recv_config.decoders[0].video_format =
SdpVideoFormat(send_config->rtp.payload_name);
recv_config.rtp.remote_ssrc = video_ssrcs_[i]; recv_config.rtp.remote_ssrc = video_ssrcs_[i];
recv_config.rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms; recv_config.rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms;

6
call/video_receive_stream.cc
View File

@ -13,7 +13,7 @@
namespace webrtc { namespace webrtc {
VideoReceiveStream::Decoder::Decoder() = default; VideoReceiveStream::Decoder::Decoder() : video_format("Unset") {}
VideoReceiveStream::Decoder::Decoder(const Decoder&) = default; VideoReceiveStream::Decoder::Decoder(const Decoder&) = default;
VideoReceiveStream::Decoder::~Decoder() = default; VideoReceiveStream::Decoder::~Decoder() = default;
@ -22,9 +22,9 @@ std::string VideoReceiveStream::Decoder::ToString() const {
rtc::SimpleStringBuilder ss(buf); rtc::SimpleStringBuilder ss(buf);
ss << "{decoder: " << (decoder ? "(VideoDecoder)" : "nullptr"); ss << "{decoder: " << (decoder ? "(VideoDecoder)" : "nullptr");
ss << ", payload_type: " << payload_type; ss << ", payload_type: " << payload_type;
ss << ", payload_name: " << payload_name; ss << ", name: " << video_format.name;
ss << ", codec_params: {"; ss << ", codec_params: {";
for (const auto& it : codec_params) for (const auto& it : video_format.parameters)
ss << it.first << ": " << it.second; ss << it.first << ": " << it.second;
ss << '}'; ss << '}';
ss << '}'; ss << '}';

11
call/video_receive_stream.h
View File

@ -22,6 +22,7 @@
#include "api/video/video_content_type.h" #include "api/video/video_content_type.h"
#include "api/video/video_sink_interface.h" #include "api/video/video_sink_interface.h"
#include "api/video/video_timing.h" #include "api/video/video_timing.h"
#include "api/video_codecs/sdp_video_format.h"
#include "call/rtp_config.h" #include "call/rtp_config.h"
#include "common_types.h" // NOLINT(build/include) #include "common_types.h" // NOLINT(build/include)
#include "common_video/include/frame_callback.h" #include "common_video/include/frame_callback.h"
@ -45,19 +46,11 @@ class VideoReceiveStream {
// The actual decoder instance. // The actual decoder instance.
VideoDecoder* decoder = nullptr; VideoDecoder* decoder = nullptr;
SdpVideoFormat video_format;
// Received RTP packets with this payload type will be sent to this decoder // Received RTP packets with this payload type will be sent to this decoder
// instance. // instance.
int payload_type = 0; int payload_type = 0;
// Name of the decoded payload (such as VP8). Maps back to the depacketizer
// used to unpack incoming packets.
std::string payload_name;
// This map contains the codec specific parameters from SDP, i.e. the "fmtp"
// parameters. It is the same as cricket::CodecParameterMap used in
// cricket::VideoCodec.
std::map<std::string, std::string> codec_params;
}; };
struct Stats { struct Stats {

6
media/engine/webrtcvideoengine.cc
View File

@ -2246,8 +2246,8 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
webrtc::VideoReceiveStream::Decoder decoder; webrtc::VideoReceiveStream::Decoder decoder;
decoder.decoder = new_decoder.get(); decoder.decoder = new_decoder.get();
decoder.payload_type = recv_codec.codec.id; decoder.payload_type = recv_codec.codec.id;
decoder.payload_name = recv_codec.codec.name; decoder.video_format =
decoder.codec_params = recv_codec.codec.params; webrtc::SdpVideoFormat(recv_codec.codec.name, recv_codec.codec.params);
config_.decoders.push_back(decoder); config_.decoders.push_back(decoder);
config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] =
recv_codec.codec.id; recv_codec.codec.id;
@ -2440,7 +2440,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
int payload_type) { int payload_type) {
for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) { for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
if (decoder.payload_type == payload_type) { if (decoder.payload_type == payload_type) {
return decoder.payload_name; return decoder.video_format.name;
} }
} }
return ""; return "";

14
media/engine/webrtcvideoengine_unittest.cc
View File

@ -4330,7 +4330,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) {
FakeVideoReceiveStream* stream = AddRecvStream(); FakeVideoReceiveStream* stream = AddRecvStream();
const webrtc::VideoReceiveStream::Config& config = stream->GetConfig(); const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name); EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].video_format.name);
EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type); EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
} }
@ -6198,17 +6198,17 @@ TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) {
EXPECT_EQ(kH264sprop1.ToCodecParameters(), rtp_parameters.codecs[0]); EXPECT_EQ(kH264sprop1.ToCodecParameters(), rtp_parameters.codecs[0]);
ASSERT_EQ(2u, cfg.decoders.size()); ASSERT_EQ(2u, cfg.decoders.size());
EXPECT_EQ(101, cfg.decoders[0].payload_type); EXPECT_EQ(101, cfg.decoders[0].payload_type);
EXPECT_EQ("H264", cfg.decoders[0].payload_name); EXPECT_EQ("H264", cfg.decoders[0].video_format.name);
const auto it0 = const auto it0 =
cfg.decoders[0].codec_params.find(kH264FmtpSpropParameterSets); cfg.decoders[0].video_format.parameters.find(kH264FmtpSpropParameterSets);
ASSERT_TRUE(it0 != cfg.decoders[0].codec_params.end()); ASSERT_TRUE(it0 != cfg.decoders[0].video_format.parameters.end());
EXPECT_EQ("uvw", it0->second); EXPECT_EQ("uvw", it0->second);
EXPECT_EQ(102, cfg.decoders[1].payload_type); EXPECT_EQ(102, cfg.decoders[1].payload_type);
EXPECT_EQ("H264", cfg.decoders[1].payload_name); EXPECT_EQ("H264", cfg.decoders[1].video_format.name);
const auto it1 = const auto it1 =
cfg.decoders[1].codec_params.find(kH264FmtpSpropParameterSets); cfg.decoders[1].video_format.parameters.find(kH264FmtpSpropParameterSets);
ASSERT_TRUE(it1 != cfg.decoders[1].codec_params.end()); ASSERT_TRUE(it1 != cfg.decoders[1].video_format.parameters.end());
EXPECT_EQ("xyz", it1->second); EXPECT_EQ("xyz", it1->second);
} }

2
test/call_test.cc
View File

@ -366,7 +366,7 @@ void CallTest::AddMatchingVideoReceiveConfigs(
} else { } else {
decoder.decoder = new test::FakeDecoder(); decoder.decoder = new test::FakeDecoder();
decoder.payload_type = video_send_config.rtp.payload_type; decoder.payload_type = video_send_config.rtp.payload_type;
decoder.payload_name = video_send_config.rtp.payload_name; decoder.video_format = SdpVideoFormat(video_send_config.rtp.payload_name);
} }
allocated_decoders_.emplace_back(decoder.decoder); allocated_decoders_.emplace_back(decoder.decoder);
video_recv_config.decoders.push_back(decoder); video_recv_config.decoders.push_back(decoder);

2
test/encoder_settings.cc
View File

@ -127,7 +127,7 @@ VideoReceiveStream::Decoder CreateMatchingDecoder(
const std::string& payload_name) { const std::string& payload_name) {
VideoReceiveStream::Decoder decoder; VideoReceiveStream::Decoder decoder;
decoder.payload_type = payload_type; decoder.payload_type = payload_type;
decoder.payload_name = payload_name; decoder.video_format = SdpVideoFormat(payload_name);
if (payload_name == "H264") { if (payload_name == "H264") {
decoder.decoder = H264Decoder::Create().release(); decoder.decoder = H264Decoder::Create().release();
} else if (payload_name == "VP8") { } else if (payload_name == "VP8") {

4
video/end_to_end_tests/codec_tests.cc
View File

@ -64,8 +64,8 @@ class CodecObserver : public test::EndToEndTest,
(*receive_configs)[0].decoders.resize(1); (*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type = (*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type; send_config->rtp.payload_type;
(*receive_configs)[0].decoders[0].payload_name = (*receive_configs)[0].decoders[0].video_format =
send_config->rtp.payload_name; SdpVideoFormat(send_config->rtp.payload_name);
(*receive_configs)[0].decoders[0].decoder = decoder_.get(); (*receive_configs)[0].decoders[0].decoder = decoder_.get();
} }

4
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -141,8 +141,8 @@ class RtcpXrObserver : public test::EndToEndTest {
(*receive_configs)[0].decoders.resize(1); (*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type = (*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type; send_config->rtp.payload_type;
(*receive_configs)[0].decoders[0].payload_name = (*receive_configs)[0].decoders[0].video_format =
send_config->rtp.payload_name; SdpVideoFormat(send_config->rtp.payload_name);
} }
if (enable_target_bitrate_) { if (enable_target_bitrate_) {
// TargetBitrate only signaled for screensharing. // TargetBitrate only signaled for screensharing.

4
video/end_to_end_tests/fec_tests.cc
View File

@ -459,8 +459,8 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
(*receive_configs)[0].decoders.resize(1); (*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type = (*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type; send_config->rtp.payload_type;
(*receive_configs)[0].decoders[0].payload_name = (*receive_configs)[0].decoders[0].video_format =
send_config->rtp.payload_name; SdpVideoFormat(send_config->rtp.payload_name);
(*receive_configs)[0].decoders[0].decoder = decoder_.get(); (*receive_configs)[0].decoders[0].decoder = decoder_.get();
} }

2
video/end_to_end_tests/histogram_tests.cc
View File

@ -88,7 +88,7 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8"; send_config->rtp.payload_name = "VP8";
encoder_config->codec_type = kVideoCodecVP8; encoder_config->codec_type = kVideoCodecVP8;
(*receive_configs)[0].decoders[0].payload_name = "VP8"; (*receive_configs)[0].decoders[0].video_format = SdpVideoFormat("VP8");
(*receive_configs)[0].rtp.red_payload_type = kRedPayloadType; (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
(*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType; (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
} }

4
video/end_to_end_tests/log_tests.cc
View File

@ -76,8 +76,8 @@ TEST_F(LogEndToEndTest, LogsEncodedFramesWhenRequested) {
(*receive_configs)[0].decoders.resize(1); (*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type = (*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type; send_config->rtp.payload_type;
(*receive_configs)[0].decoders[0].payload_name = (*receive_configs)[0].decoders[0].video_format =
send_config->rtp.payload_name; SdpVideoFormat(send_config->rtp.payload_name);
(*receive_configs)[0].decoders[0].decoder = decoder_.get(); (*receive_configs)[0].decoders[0].decoder = decoder_.get();
} }

2
video/end_to_end_tests/retransmission_tests.cc
View File

@ -432,7 +432,7 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8"; send_config->rtp.payload_name = "VP8";
encoder_config->codec_type = kVideoCodecVP8; encoder_config->codec_type = kVideoCodecVP8;
(*receive_configs)[0].decoders[0].payload_name = "VP8"; (*receive_configs)[0].decoders[0].video_format = SdpVideoFormat("VP8");
} }
void OnFrameGeneratorCapturerCreated( void OnFrameGeneratorCapturerCreated(

8
video/replay.cc
View File

@ -241,12 +241,14 @@ class VideoReceiveStreamConfigDeserializer final {
auto receive_config = VideoReceiveStream::Config(transport); auto receive_config = VideoReceiveStream::Config(transport);
for (const auto decoder_json : json["decoders"]) { for (const auto decoder_json : json["decoders"]) {
VideoReceiveStream::Decoder decoder; VideoReceiveStream::Decoder decoder;
decoder.payload_name = decoder_json["payload_name"].asString(); decoder.video_format =
SdpVideoFormat(decoder_json["payload_name"].asString());
decoder.payload_type = decoder_json["payload_type"].asInt64(); decoder.payload_type = decoder_json["payload_type"].asInt64();
for (const auto& params_json : decoder_json["codec_params"]) { for (const auto& params_json : decoder_json["codec_params"]) {
std::vector<std::string> members = params_json.getMemberNames(); std::vector<std::string> members = params_json.getMemberNames();
RTC_CHECK_EQ(members.size(), 1); RTC_CHECK_EQ(members.size(), 1);
decoder.codec_params[members[0]] = params_json[members[0]].asString(); decoder.video_format.parameters[members[0]] =
params_json[members[0]].asString();
} }
receive_config.decoders.push_back(decoder); receive_config.decoders.push_back(decoder);
} }
@ -356,7 +358,7 @@ class RtpReplayer final {
// Instantiate the underlying decoder. // Instantiate the underlying decoder.
for (auto& decoder : receive_config.decoders) { for (auto& decoder : receive_config.decoders) {
decoder.decoder = test::CreateMatchingDecoder(decoder.payload_type, decoder.decoder = test::CreateMatchingDecoder(decoder.payload_type,
decoder.payload_name) decoder.video_format.name)
.decoder; .decoder;
} }
// Create a window for this config. // Create a window for this config.

10
video/video_receive_stream.cc
View File

@ -48,7 +48,7 @@ VideoCodec CreateDecoderVideoCodec(const VideoReceiveStream::Decoder& decoder) {
memset(&codec, 0, sizeof(codec)); memset(&codec, 0, sizeof(codec));
codec.plType = decoder.payload_type; codec.plType = decoder.payload_type;
codec.codecType = PayloadStringToCodecType(decoder.payload_name); codec.codecType = PayloadStringToCodecType(decoder.video_format.name);
if (codec.codecType == kVideoCodecVP8) { if (codec.codecType == kVideoCodecVP8) {
*(codec.VP8()) = VideoEncoder::GetDefaultVp8Settings(); *(codec.VP8()) = VideoEncoder::GetDefaultVp8Settings();
@ -57,10 +57,11 @@ VideoCodec CreateDecoderVideoCodec(const VideoReceiveStream::Decoder& decoder) {
} else if (codec.codecType == kVideoCodecH264) { } else if (codec.codecType == kVideoCodecH264) {
*(codec.H264()) = VideoEncoder::GetDefaultH264Settings(); *(codec.H264()) = VideoEncoder::GetDefaultH264Settings();
codec.H264()->profile = codec.H264()->profile =
H264::ParseSdpProfileLevelId(decoder.codec_params)->profile; H264::ParseSdpProfileLevelId(decoder.video_format.parameters)->profile;
} else if (codec.codecType == kVideoCodecMultiplex) { } else if (codec.codecType == kVideoCodecMultiplex) {
VideoReceiveStream::Decoder associated_decoder = decoder; VideoReceiveStream::Decoder associated_decoder = decoder;
associated_decoder.payload_name = CodecTypeToPayloadString(kVideoCodecVP9); associated_decoder.video_format =
SdpVideoFormat(CodecTypeToPayloadString(kVideoCodecVP9));
VideoCodec associated_codec = CreateDecoderVideoCodec(associated_decoder); VideoCodec associated_codec = CreateDecoderVideoCodec(associated_decoder);
associated_codec.codecType = kVideoCodecMultiplex; associated_codec.codecType = kVideoCodecMultiplex;
return associated_codec; return associated_codec;
@ -205,7 +206,8 @@ void VideoReceiveStream::Start() {
video_receiver_.RegisterExternalDecoder(decoder.decoder, video_receiver_.RegisterExternalDecoder(decoder.decoder,
decoder.payload_type); decoder.payload_type);
VideoCodec codec = CreateDecoderVideoCodec(decoder); VideoCodec codec = CreateDecoderVideoCodec(decoder);
rtp_video_stream_receiver_.AddReceiveCodec(codec, decoder.codec_params); rtp_video_stream_receiver_.AddReceiveCodec(codec,
decoder.video_format.parameters);
RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec( RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
&codec, num_cpu_cores_, false)); &codec, num_cpu_cores_, false));
} }

6
video/video_receive_stream_unittest.cc
View File

@ -74,14 +74,14 @@ class VideoReceiveStreamTest : public testing::Test {
config_.renderer = &fake_renderer_; config_.renderer = &fake_renderer_;
VideoReceiveStream::Decoder h264_decoder; VideoReceiveStream::Decoder h264_decoder;
h264_decoder.payload_type = 99; h264_decoder.payload_type = 99;
h264_decoder.payload_name = "H264"; h264_decoder.video_format = SdpVideoFormat("H264");
h264_decoder.codec_params.insert( h264_decoder.video_format.parameters.insert(
{"sprop-parameter-sets", "Z0IACpZTBYmI,aMljiA=="}); {"sprop-parameter-sets", "Z0IACpZTBYmI,aMljiA=="});
h264_decoder.decoder = &mock_h264_video_decoder_; h264_decoder.decoder = &mock_h264_video_decoder_;
config_.decoders.push_back(h264_decoder); config_.decoders.push_back(h264_decoder);
VideoReceiveStream::Decoder null_decoder; VideoReceiveStream::Decoder null_decoder;
null_decoder.payload_type = 98; null_decoder.payload_type = 98;
null_decoder.payload_name = "null"; null_decoder.video_format = SdpVideoFormat("null");
null_decoder.decoder = &mock_null_video_decoder_; null_decoder.decoder = &mock_null_video_decoder_;
config_.decoders.push_back(null_decoder); config_.decoders.push_back(null_decoder);