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

Untangle ViEChannel and ViEEncoder.

Browse Source 
Extracts shared members outside the two objects, removing PayloadRouter
from receivers and the VCM for ViEChannel from senders.

Removes Start/StopThreadsAndSetSharedMembers that was used to set the
shared state between them.

Also adding DCHECKs to document what's only used by the
sender/receiver side.

BUG=webrtc:5494
R=stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1654913002 .

Cr-Commit-Position: refs/heads/master@{#11500}
This commit is contained in:
Peter Boström
2016-02-05 11:25:46 +01:00
parent e449915455
commit 1d04ac6f29
13 changed files with 105 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/modules/video_coding/include/video_coding.h
View File

@ -75,8 +75,6 @@ class VideoCodingModule : public Module {
static VideoCodingModule* Create(Clock* clock, EventFactory* event_factory);
static void Destroy(VideoCodingModule* module);
// Get supported codec settings using codec type
//
// Input:

5
webrtc/modules/video_coding/video_coding_impl.cc
View File

@ -310,9 +310,4 @@ VideoCodingModule* VideoCodingModule::Create(Clock* clock,
nullptr);
}
void VideoCodingModule::Destroy(VideoCodingModule* module) {
if (module != NULL) {
delete static_cast<VideoCodingModuleImpl*>(module);
}
}
} // namespace webrtc

6
webrtc/modules/video_coding/video_coding_robustness_unittest.cc
View File

@ -35,7 +35,7 @@ class VCMRobustnessTest : public ::testing::Test {
virtual void SetUp() {
clock_.reset(new SimulatedClock(0));
ASSERT_TRUE(clock_.get() != NULL);
vcm_ = VideoCodingModule::Create(clock_.get(), &event_factory_);
vcm_.reset(VideoCodingModule::Create(clock_.get(), &event_factory_));
ASSERT_TRUE(vcm_ != NULL);
const size_t kMaxNackListSize = 250;
const int kMaxPacketAgeToNack = 450;
@ -47,7 +47,7 @@ class VCMRobustnessTest : public ::testing::Test {
vcm_->RegisterExternalDecoder(&decoder_, video_codec_.plType);
}
virtual void TearDown() { VideoCodingModule::Destroy(vcm_); }
virtual void TearDown() { vcm_.reset(); }
void InsertPacket(uint32_t timestamp,
uint16_t seq_no,
@ -69,7 +69,7 @@ class VCMRobustnessTest : public ::testing::Test {
ASSERT_EQ(VCM_OK, vcm_->IncomingPacket(payload, kPayloadLen, rtp_info));
}
VideoCodingModule* vcm_;
rtc::scoped_ptr<VideoCodingModule> vcm_;
VideoCodec video_codec_;
MockVCMFrameTypeCallback frame_type_callback_;
MockPacketRequestCallback request_callback_;

1
webrtc/video/encoder_state_feedback_unittest.cc
View File

@ -37,6 +37,7 @@ class MockVieEncoder : public ViEEncoder {
nullptr,
nullptr,
pacer,
nullptr,
nullptr) {}
~MockVieEncoder() {}

16
webrtc/video/video_receive_stream.cc
View File

@ -19,6 +19,7 @@
#include "webrtc/base/logging.h"
#include "webrtc/call/congestion_controller.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/utility/include/process_thread.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/video/call_stats.h"
#include "webrtc/video/receive_statistics_proxy.h"
@ -148,9 +149,11 @@ VideoReceiveStream::VideoReceiveStream(
: transport_adapter_(config.rtcp_send_transport),
encoded_frame_proxy_(config.pre_decode_callback),
config_(config),
process_thread_(process_thread),
clock_(Clock::GetRealTimeClock()),
congestion_controller_(congestion_controller),
call_stats_(call_stats) {
call_stats_(call_stats),
vcm_(VideoCodingModule::Create(clock_, nullptr, nullptr)) {
LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString();
bool send_side_bwe =
@ -160,10 +163,10 @@ VideoReceiveStream::VideoReceiveStream(
congestion_controller_->GetRemoteBitrateEstimator(send_side_bwe);
vie_channel_.reset(new ViEChannel(
num_cpu_cores, &transport_adapter_, process_thread, nullptr,
nullptr, nullptr, bitrate_estimator, call_stats_->rtcp_rtt_stats(),
congestion_controller_->pacer(), congestion_controller_->packet_router(),
1, false));
num_cpu_cores, &transport_adapter_, process_thread, nullptr, vcm_.get(),
nullptr, nullptr, nullptr, bitrate_estimator,
call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(),
congestion_controller_->packet_router(), 1, false));
RTC_CHECK(vie_channel_->Init() == 0);
@ -284,11 +287,14 @@ VideoReceiveStream::VideoReceiveStream(
vie_channel_->RegisterPreDecodeImageCallback(this);
vie_channel_->RegisterPreRenderCallback(this);
process_thread_->RegisterModule(vcm_.get());
}
VideoReceiveStream::~VideoReceiveStream() {
LOG(LS_INFO) << "~VideoReceiveStream: " << config_.ToString();
incoming_video_stream_->Stop();
process_thread_->DeRegisterModule(vcm_.get());
vie_channel_->RegisterPreRenderCallback(nullptr);
vie_channel_->RegisterPreDecodeImageCallback(nullptr);

3
webrtc/video/video_receive_stream.h
View File

@ -21,6 +21,7 @@
#include "webrtc/modules/video_render/video_render_defines.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/video/encoded_frame_callback_adapter.h"
#include "webrtc/video/payload_router.h"
#include "webrtc/video/receive_statistics_proxy.h"
#include "webrtc/video/vie_channel.h"
#include "webrtc/video/vie_encoder.h"
@ -80,11 +81,13 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
TransportAdapter transport_adapter_;
EncodedFrameCallbackAdapter encoded_frame_proxy_;
const VideoReceiveStream::Config config_;
ProcessThread* const process_thread_;
Clock* const clock_;
CongestionController* const congestion_controller_;
CallStats* const call_stats_;
rtc::scoped_ptr<VideoCodingModule> vcm_;
rtc::scoped_ptr<IncomingVideoStream> incoming_video_stream_;
rtc::scoped_ptr<ReceiveStatisticsProxy> stats_proxy_;
rtc::scoped_ptr<ViEChannel> vie_channel_;

25
webrtc/video/video_send_stream.cc
View File

@ -25,7 +25,6 @@
#include "webrtc/modules/utility/include/process_thread.h"
#include "webrtc/video/call_stats.h"
#include "webrtc/video/encoder_state_feedback.h"
#include "webrtc/video/payload_router.h"
#include "webrtc/video/video_capture_input.h"
#include "webrtc/video/vie_channel.h"
#include "webrtc/video/vie_encoder.h"
@ -163,28 +162,27 @@ VideoSendStream::VideoSendStream(
const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
vie_encoder_.reset(
new ViEEncoder(num_cpu_cores, module_process_thread_, &stats_proxy_,
vie_encoder_.reset(new ViEEncoder(
num_cpu_cores, module_process_thread_, &stats_proxy_,
config.pre_encode_callback, &overuse_detector_,
congestion_controller_->pacer(), bitrate_allocator));
congestion_controller_->pacer(), &payload_router_, bitrate_allocator));
vcm_ = vie_encoder_->vcm();
RTC_CHECK(vie_encoder_->Init());
vie_channel_.reset(new ViEChannel(
num_cpu_cores, config.send_transport, module_process_thread_,
encoder_feedback_->GetRtcpIntraFrameObserver(),
congestion_controller_->GetBitrateController()->
CreateRtcpBandwidthObserver(),
&payload_router_, nullptr, encoder_feedback_->GetRtcpIntraFrameObserver(),
congestion_controller_->GetBitrateController()
->CreateRtcpBandwidthObserver(),
transport_feedback_observer,
congestion_controller_->GetRemoteBitrateEstimator(false),
call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(),
congestion_controller_->packet_router(), ssrcs.size(), true));
RTC_CHECK(vie_channel_->Init() == 0);
call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver());
vcm_->RegisterProtectionCallback(vie_channel_->vcm_protection_callback());
vie_encoder_->StartThreadsAndSetSharedMembers(
vie_channel_->send_payload_router(),
vie_channel_->vcm_protection_callback());
call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver());
std::vector<uint32_t> first_ssrc(1, ssrcs[0]);
vie_encoder_->SetSsrcs(first_ssrc);
@ -266,6 +264,10 @@ VideoSendStream::VideoSendStream(
VideoSendStream::~VideoSendStream() {
LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
module_process_thread_->DeRegisterModule(&overuse_detector_);
// Remove vcm_protection_callback (part of vie_channel_) before destroying
// ViEChannel. vcm_ is owned by ViEEncoder and the registered callback does
// not outlive it.
vcm_->RegisterProtectionCallback(nullptr);
vie_channel_->RegisterSendFrameCountObserver(nullptr);
vie_channel_->RegisterSendBitrateObserver(nullptr);
vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr);
@ -287,7 +289,6 @@ VideoSendStream::~VideoSendStream() {
// done before deleting the channel.
congestion_controller_->RemoveEncoder(vie_encoder_.get());
encoder_feedback_->RemoveEncoder(vie_encoder_.get());
vie_encoder_->StopThreadsAndRemoveSharedMembers();
uint32_t remote_ssrc = vie_channel_->GetRemoteSSRC();
congestion_controller_->GetRemoteBitrateEstimator(false)->RemoveStream(

7
webrtc/video/video_send_stream.h
View File

@ -19,6 +19,7 @@
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/video/encoded_frame_callback_adapter.h"
#include "webrtc/video/payload_router.h"
#include "webrtc/video/send_statistics_proxy.h"
#include "webrtc/video/video_capture_input.h"
#include "webrtc/video_receive_stream.h"
@ -88,8 +89,12 @@ class VideoSendStream : public webrtc::VideoSendStream,
OveruseFrameDetector overuse_detector_;
rtc::scoped_ptr<VideoCaptureInput> input_;
rtc::scoped_ptr<ViEChannel> vie_channel_;
PayloadRouter payload_router_;
rtc::scoped_ptr<ViEEncoder> vie_encoder_;
rtc::scoped_ptr<ViEChannel> vie_channel_;
// TODO(pbos): Make proper const.
// const after construction.
VideoCodingModule* vcm_;
rtc::scoped_ptr<EncoderStateFeedback> encoder_feedback_;
// Used as a workaround to indicate that we should be using the configured

64
webrtc/video/vie_channel.cc
View File

@ -80,6 +80,8 @@ class ViEChannelProtectionCallback : public VCMProtectionCallback {
ViEChannel::ViEChannel(uint32_t number_of_cores,
Transport* transport,
ProcessThread* module_process_thread,
PayloadRouter* send_payload_router,
VideoCodingModule* vcm,
RtcpIntraFrameObserver* intra_frame_observer,
RtcpBandwidthObserver* bandwidth_observer,
TransportFeedbackObserver* transport_feedback_observer,
@ -92,11 +94,9 @@ ViEChannel::ViEChannel(uint32_t number_of_cores,
: number_of_cores_(number_of_cores),
sender_(sender),
module_process_thread_(module_process_thread),
send_payload_router_(new PayloadRouter()),
send_payload_router_(send_payload_router),
vcm_protection_callback_(new ViEChannelProtectionCallback(this)),
vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
nullptr,
nullptr)),
vcm_(vcm),
vie_receiver_(vcm_, remote_bitrate_estimator, this),
vie_sync_(vcm_),
stats_observer_(new ChannelStatsObserver(this)),
@ -135,7 +135,14 @@ ViEChannel::ViEChannel(uint32_t number_of_cores,
max_rtp_streams)),
num_active_rtp_rtcp_modules_(1) {
vie_receiver_.SetRtpRtcpModule(rtp_rtcp_modules_[0]);
if (sender_) {
RTC_DCHECK(send_payload_router_);
RTC_DCHECK(!vcm_);
} else {
RTC_DCHECK(!send_payload_router_);
RTC_DCHECK(vcm_);
vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 0);
}
}
int32_t ViEChannel::Init() {
@ -155,7 +162,7 @@ int32_t ViEChannel::Init() {
std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]);
send_payload_router_->SetSendingRtpModules(send_rtp_modules);
RTC_DCHECK(!send_payload_router_->active());
}
} else {
if (vcm_->RegisterReceiveCallback(this) != 0) {
return -1;
}
@ -163,10 +170,8 @@ int32_t ViEChannel::Init() {
vcm_->RegisterReceiveStatisticsCallback(this);
vcm_->RegisterDecoderTimingCallback(this);
vcm_->SetRenderDelay(kDefaultRenderDelayMs);
module_process_thread_->RegisterModule(vcm_);
module_process_thread_->RegisterModule(&vie_sync_);
}
return 0;
}
@ -175,9 +180,11 @@ ViEChannel::~ViEChannel() {
// Make sure we don't get more callbacks from the RTP module.
module_process_thread_->DeRegisterModule(
vie_receiver_.GetReceiveStatistics());
module_process_thread_->DeRegisterModule(vcm_);
module_process_thread_->DeRegisterModule(&vie_sync_);
if (sender_) {
send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>());
} else {
module_process_thread_->DeRegisterModule(&vie_sync_);
}
for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i)
packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
@ -186,8 +193,6 @@ ViEChannel::~ViEChannel() {
}
if (!sender_)
StopDecodeThread();
// Release modules.
VideoCodingModule::Destroy(vcm_);
}
void ViEChannel::UpdateHistograms() {
@ -441,15 +446,8 @@ int32_t ViEChannel::ReceiveCodecStatistics(uint32_t* num_key_frames,
return 0;
}
uint32_t ViEChannel::DiscardedPackets() const {
return vcm_->DiscardedPackets();
}
int ViEChannel::ReceiveDelay() const {
return vcm_->Delay();
}
void ViEChannel::SetExpectedRenderDelay(int delay_ms) {
RTC_DCHECK(!sender_);
vcm_->SetRenderDelay(delay_ms);
}
@ -483,6 +481,7 @@ void ViEChannel::SetProtectionMode(bool enable_nack,
protection_method = kProtectionNone;
}
if (!sender_)
vcm_->SetVideoProtection(protection_method, true);
// Set NACK.
@ -506,20 +505,22 @@ void ViEChannel::ProcessNACKRequest(const bool enable) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
if (!sender_) {
vcm_->RegisterPacketRequestCallback(this);
// Don't introduce errors when NACK is enabled.
vcm_->SetDecodeErrorMode(kNoErrors);
}
} else {
vcm_->RegisterPacketRequestCallback(NULL);
if (paced_sender_ == nullptr) {
if (!sender_) {
vcm_->RegisterPacketRequestCallback(nullptr);
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetStorePacketsStatus(false, 0);
}
vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_);
// When NACK is off, allow decoding with errors. Otherwise, the video
// will freeze, and will only recover with a complete key frame.
vcm_->SetDecodeErrorMode(kWithErrors);
}
vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_);
}
}
bool ViEChannel::IsSendingFecEnabled() {
@ -880,14 +881,17 @@ int32_t ViEChannel::StartSend() {
for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) {
RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[i];
rtp_rtcp->SetSendingMediaStatus(true);
// Only have senders send media.
rtp_rtcp->SetSendingMediaStatus(sender_);
rtp_rtcp->SetSendingStatus(true);
}
if (sender_)
send_payload_router_->set_active(true);
return 0;
}
int32_t ViEChannel::StopSend() {
if (sender_)
send_payload_router_->set_active(false);
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetSendingMediaStatus(false);
@ -940,10 +944,6 @@ RtpRtcp* ViEChannel::rtp_rtcp() {
return rtp_rtcp_modules_[0];
}
rtc::scoped_refptr<PayloadRouter> ViEChannel::send_payload_router() {
return send_payload_router_;
}
VCMProtectionCallback* ViEChannel::vcm_protection_callback() {
return vcm_protection_callback_.get();
}
@ -1038,11 +1038,13 @@ bool ViEChannel::ChannelDecodeThreadFunction(void* obj) {
}
bool ViEChannel::ChannelDecodeProcess() {
RTC_DCHECK(!sender_);
vcm_->Decode(kMaxDecodeWaitTimeMs);
return true;
}
void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
if (!sender_)
vcm_->SetReceiveChannelParameters(max_rtt_ms);
rtc::CritScope lock(&crit_);
@ -1137,6 +1139,7 @@ void ViEChannel::StartDecodeThread() {
}
void ViEChannel::StopDecodeThread() {
RTC_DCHECK(!sender_);
vcm_->TriggerDecoderShutdown();
decode_thread_.Stop();
@ -1144,12 +1147,14 @@ void ViEChannel::StopDecodeThread() {
int32_t ViEChannel::SetVoiceChannel(int32_t ve_channel_id,
VoEVideoSync* ve_sync_interface) {
RTC_DCHECK(!sender_);
return vie_sync_.ConfigureSync(ve_channel_id, ve_sync_interface,
rtp_rtcp_modules_[0],
vie_receiver_.GetRtpReceiver());
}
int32_t ViEChannel::VoiceChannel() {
RTC_DCHECK(!sender_);
return vie_sync_.VoiceChannel();
}
@ -1161,6 +1166,7 @@ void ViEChannel::RegisterPreRenderCallback(
void ViEChannel::RegisterPreDecodeImageCallback(
EncodedImageCallback* pre_decode_callback) {
RTC_DCHECK(!sender_);
vcm_->RegisterPreDecodeImageCallback(pre_decode_callback);
}

10
webrtc/video/vie_channel.h
View File

@ -68,6 +68,8 @@ class ViEChannel : public VCMFrameTypeCallback,
ViEChannel(uint32_t number_of_cores,
Transport* transport,
ProcessThread* module_process_thread,
PayloadRouter* send_payload_router,
VideoCodingModule* vcm,
RtcpIntraFrameObserver* intra_frame_observer,
RtcpBandwidthObserver* bandwidth_observer,
TransportFeedbackObserver* transport_feedback_observer,
@ -89,11 +91,6 @@ class ViEChannel : public VCMFrameTypeCallback,
void RegisterExternalDecoder(const uint8_t pl_type, VideoDecoder* decoder);
int32_t ReceiveCodecStatistics(uint32_t* num_key_frames,
uint32_t* num_delta_frames);
uint32_t DiscardedPackets() const;
// Returns the estimated delay in milliseconds.
int ReceiveDelay() const;
void SetExpectedRenderDelay(int delay_ms);
void SetRTCPMode(const RtcpMode rtcp_mode);
@ -214,7 +211,6 @@ class ViEChannel : public VCMFrameTypeCallback,
// Gets the modules used by the channel.
RtpRtcp* rtp_rtcp();
rtc::scoped_refptr<PayloadRouter> send_payload_router();
VCMProtectionCallback* vcm_protection_callback();
@ -401,12 +397,12 @@ class ViEChannel : public VCMFrameTypeCallback,
const bool sender_;
ProcessThread* const module_process_thread_;
PayloadRouter* const send_payload_router_;
// Used for all registered callbacks except rendering.
rtc::CriticalSection crit_;
// Owned modules/classes.
rtc::scoped_refptr<PayloadRouter> send_payload_router_;
rtc::scoped_ptr<ViEChannelProtectionCallback> vcm_protection_callback_;
VideoCodingModule* const vcm_;

24
webrtc/video/vie_encoder.cc
View File

@ -110,6 +110,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores,
I420FrameCallback* pre_encode_callback,
OveruseFrameDetector* overuse_detector,
PacedSender* pacer,
PayloadRouter* payload_router,
BitrateAllocator* bitrate_allocator)
: number_of_cores_(number_of_cores),
vp_(VideoProcessing::Create()),
@ -117,11 +118,11 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores,
vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
this,
qm_callback_.get())),
send_payload_router_(NULL),
stats_proxy_(stats_proxy),
pre_encode_callback_(pre_encode_callback),
overuse_detector_(overuse_detector),
pacer_(pacer),
send_payload_router_(payload_router),
bitrate_allocator_(bitrate_allocator),
time_of_last_frame_activity_ms_(0),
encoder_config_(),
@ -138,6 +139,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores,
picture_id_rpsi_(0),
video_suspended_(false) {
bitrate_observer_.reset(new ViEBitrateObserver(this));
module_process_thread_->RegisterModule(vcm_.get());
}
bool ViEEncoder::Init() {
@ -155,23 +157,14 @@ bool ViEEncoder::Init() {
return true;
}
void ViEEncoder::StartThreadsAndSetSharedMembers(
rtc::scoped_refptr<PayloadRouter> send_payload_router,
VCMProtectionCallback* vcm_protection_callback) {
RTC_DCHECK(send_payload_router_ == NULL);
send_payload_router_ = send_payload_router;
vcm_->RegisterProtectionCallback(vcm_protection_callback);
module_process_thread_->RegisterModule(vcm_.get());
}
void ViEEncoder::StopThreadsAndRemoveSharedMembers() {
if (bitrate_allocator_)
bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
module_process_thread_->DeRegisterModule(vcm_.get());
VideoCodingModule* ViEEncoder::vcm() const {
return vcm_.get();
}
ViEEncoder::~ViEEncoder() {
module_process_thread_->DeRegisterModule(vcm_.get());
if (bitrate_allocator_)
bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
}
void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) {
@ -338,7 +331,6 @@ void ViEEncoder::TraceFrameDropEnd() {
}
void ViEEncoder::DeliverFrame(VideoFrame video_frame) {
RTC_DCHECK(send_payload_router_ != NULL);
if (!send_payload_router_->active()) {
// We've paused or we have no channels attached, don't waste resources on
// encoding.

15
webrtc/video/vie_encoder.h
View File

@ -57,22 +57,13 @@ class ViEEncoder : public RtcpIntraFrameObserver,
I420FrameCallback* pre_encode_callback,
OveruseFrameDetector* overuse_detector,
PacedSender* pacer,
PayloadRouter* payload_router,
BitrateAllocator* bitrate_allocator);
~ViEEncoder();
bool Init();
// This function is assumed to be called before any frames are delivered and
// only once.
// Ideally this would be done in Init, but the dependencies between ViEEncoder
// and ViEChannel makes it really hard to do in a good way.
void StartThreadsAndSetSharedMembers(
rtc::scoped_refptr<PayloadRouter> send_payload_router,
VCMProtectionCallback* vcm_protection_callback);
// This function must be called before the corresponding ViEChannel is
// deleted.
void StopThreadsAndRemoveSharedMembers();
VideoCodingModule* vcm() const;
void SetNetworkTransmissionState(bool is_transmitting);
@ -158,7 +149,6 @@ class ViEEncoder : public RtcpIntraFrameObserver,
const rtc::scoped_ptr<VideoProcessing> vp_;
const rtc::scoped_ptr<QMVideoSettingsCallback> qm_callback_;
const rtc::scoped_ptr<VideoCodingModule> vcm_;
rtc::scoped_refptr<PayloadRouter> send_payload_router_;
rtc::CriticalSection data_cs_;
rtc::scoped_ptr<BitrateObserver> bitrate_observer_;
@ -167,6 +157,7 @@ class ViEEncoder : public RtcpIntraFrameObserver,
I420FrameCallback* const pre_encode_callback_;
OveruseFrameDetector* const overuse_detector_;
PacedSender* const pacer_;
PayloadRouter* const send_payload_router_;
BitrateAllocator* const bitrate_allocator_;
// The time we last received an input frame or encoded frame. This is used to

1
webrtc/video/vie_receiver.cc
View File

@ -232,6 +232,7 @@ int ViEReceiver::ReceivedRTCPPacket(const void* rtcp_packet,
int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data,
const size_t payload_size,
const WebRtcRTPHeader* rtp_header) {
RTC_DCHECK(vcm_);
WebRtcRTPHeader rtp_header_with_ntp = *rtp_header;
rtp_header_with_ntp.ntp_time_ms =
ntp_estimator_->Estimate(rtp_header->header.timestamp);