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

Add a VideoCoding::RegisterReceiveCodec method with payload_type

Browse Source 
Intended to ease removal of VideoCodec::plType, separating video
coding from transport.

Bug: None
Change-Id: I0764f2f714eab9ee4c3e55751819cd5915fb37b6
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/181075
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31892}
This commit is contained in:
Niels Möller
2020-08-07 16:19:56 +02:00
committed by Commit Bot
parent cf11d1ddbe
commit 582102c9b7
11 changed files with 39 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
modules/video_coding/decoder_database.cc
View File

@ -70,15 +70,16 @@ void VCMDecoderDataBase::RegisterExternalDecoder(VideoDecoder* external_decoder,
dec_external_map_[payload_type] = ext_decoder;
}
bool VCMDecoderDataBase::RegisterReceiveCodec(const VideoCodec* receive_codec,
bool VCMDecoderDataBase::RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receive_codec,
int number_of_cores) {
if (number_of_cores < 0) {
return false;
}
// If payload value already exists, erase old and insert new.
DeregisterReceiveCodec(receive_codec->plType);
DeregisterReceiveCodec(payload_type);
VideoCodec* new_receive_codec = new VideoCodec(*receive_codec);
dec_map_[receive_codec->plType] =
dec_map_[payload_type] =
new VCMDecoderMapItem(new_receive_codec, number_of_cores);
return true;
}

3
modules/video_coding/decoder_database.h
View File

@ -45,7 +45,8 @@ class VCMDecoderDataBase {
void RegisterExternalDecoder(VideoDecoder* external_decoder,
uint8_t payload_type);
bool RegisterReceiveCodec(const VideoCodec* receive_codec,
bool RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receive_codec,
int number_of_cores);
bool DeregisterReceiveCodec(uint8_t payload_type);

10
modules/video_coding/include/video_coding.h
View File

@ -42,19 +42,21 @@ class VideoCodingModule : public Module {
// needed.
//
// Input:
// - payload_type : RTP payload type
// - receiveCodec : Settings for the codec to be registered.
// - numberOfCores : Number of CPU cores that the decoder is allowed
// to use.
// - requireKeyFrame : Set this to true if you don't want any delta
// frames
// to be decoded until the first key frame has been
// decoded.
//
// Return value : VCM_OK, on success.
// < 0, on error.
// TODO(nisse): Method without explicit payload type is deprecated.
virtual int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t numberOfCores) = 0;
virtual int32_t RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receiveCodec,
int32_t numberOfCores) = 0;
// Register an external decoder object.
//
// Input:

10
modules/video_coding/video_coding_impl.cc
View File

@ -58,7 +58,15 @@ class VideoCodingModuleImpl : public VideoCodingModule {
int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t numberOfCores) override {
return receiver_.RegisterReceiveCodec(receiveCodec, numberOfCores);
return RegisterReceiveCodec(receiveCodec->plType, receiveCodec,
numberOfCores);
}
int32_t RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receiveCodec,
int32_t numberOfCores) override {
return receiver_.RegisterReceiveCodec(payload_type, receiveCodec,
numberOfCores);
}
void RegisterExternalDecoder(VideoDecoder* externalDecoder,

3
modules/video_coding/video_coding_impl.h
View File

@ -60,7 +60,8 @@ class VideoReceiver : public Module {
VideoReceiver(Clock* clock, VCMTiming* timing);
~VideoReceiver() override;
int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receiveCodec,
int32_t numberOfCores);
void RegisterExternalDecoder(VideoDecoder* externalDecoder,

6
modules/video_coding/video_receiver.cc
View File

@ -250,13 +250,15 @@ int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
}
// Register possible receive codecs, can be called multiple times
int32_t VideoReceiver::RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t VideoReceiver::RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receiveCodec,
int32_t numberOfCores) {
RTC_DCHECK_RUN_ON(&construction_thread_checker_);
if (receiveCodec == nullptr) {
return VCM_PARAMETER_ERROR;
}
if (!_codecDataBase.RegisterReceiveCodec(receiveCodec, numberOfCores)) {
if (!_codecDataBase.RegisterReceiveCodec(payload_type, receiveCodec,
numberOfCores)) {
return -1;
}
return 0;

6
modules/video_coding/video_receiver2.cc
View File

@ -95,14 +95,16 @@ int32_t VideoReceiver2::Decode(const VCMEncodedFrame* frame) {
}
// Register possible receive codecs, can be called multiple times
int32_t VideoReceiver2::RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t VideoReceiver2::RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receiveCodec,
int32_t numberOfCores) {
RTC_DCHECK_RUN_ON(&construction_thread_checker_);
RTC_DCHECK(!IsDecoderThreadRunning());
if (receiveCodec == nullptr) {
return VCM_PARAMETER_ERROR;
}
if (!codecDataBase_.RegisterReceiveCodec(receiveCodec, numberOfCores)) {
if (!codecDataBase_.RegisterReceiveCodec(payload_type, receiveCodec,
numberOfCores)) {
return -1;
}
return 0;

3
modules/video_coding/video_receiver2.h
View File

@ -30,7 +30,8 @@ class VideoReceiver2 {
VideoReceiver2(Clock* clock, VCMTiming* timing);
~VideoReceiver2();
int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t RegisterReceiveCodec(uint8_t payload_type,
const VideoCodec* receiveCodec,
int32_t numberOfCores);
void RegisterExternalDecoder(VideoDecoder* externalDecoder,

3
modules/video_coding/video_receiver_unittest.cc
View File

@ -58,7 +58,8 @@ class TestVideoReceiver : public ::testing::Test {
receiver_.RegisterExternalDecoder(&decoder_, kUnusedPayloadType);
webrtc::test::CodecSettings(kVideoCodecVP8, &settings_);
settings_.plType = kUnusedPayloadType;
EXPECT_EQ(0, receiver_.RegisterReceiveCodec(&settings_, 1));
EXPECT_EQ(
0, receiver_.RegisterReceiveCodec(kUnusedPayloadType, &settings_, 1));
// Set protection mode.
const size_t kMaxNackListSize = 250;

4
video/video_receive_stream.cc
View File

@ -375,8 +375,8 @@ void VideoReceiveStream::Start() {
config_.rtp.raw_payload_types.count(codec.plType) > 0;
rtp_video_stream_receiver_.AddReceiveCodec(
codec, decoder.video_format.parameters, raw_payload);
RTC_CHECK_EQ(VCM_OK,
video_receiver_.RegisterReceiveCodec(&codec, num_cpu_cores_));
RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
decoder.payload_type, &codec, num_cpu_cores_));
}
RTC_DCHECK(renderer != nullptr);

4
video/video_receive_stream2.cc
View File

@ -351,8 +351,8 @@ void VideoReceiveStream2::Start() {
config_.rtp.raw_payload_types.count(codec.plType) > 0;
rtp_video_stream_receiver_.AddReceiveCodec(
codec, decoder.video_format.parameters, raw_payload);
RTC_CHECK_EQ(VCM_OK,
video_receiver_.RegisterReceiveCodec(&codec, num_cpu_cores_));
RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec(
decoder.payload_type, &codec, num_cpu_cores_));
}
RTC_DCHECK(renderer != nullptr);