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

Create VideoReceiver with external VCMTiming object.

Browse Source 
In order for the VCMTiming object to be correctly updated with decoding timings
when running the WebRTC-NewVideoJitterBuffer experiment the VCMTiming object
has to be available in both the VideoReceiver and the video_coding::FrameBuffer
class. Therefore the VCMTiming object is created in VideoRecieveStream and
then passed to VideoReceiver/video_coding::FrameBuffer as they are constructed.

BUG=webrtc:5514

Review-Url: https://codereview.webrtc.org/2575473004
Cr-Commit-Position: refs/heads/master@{#15638}
This commit is contained in:
philipel
2016-12-15 07:10:57 -08:00
committed by Commit bot
parent ac8d5164f0
commit 721d402d71
6 changed files with 28 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -13,16 +13,17 @@
#include <algorithm>
#include <utility>
#include "webrtc/base/criticalsection.h"
#include "webrtc/common_types.h"
#include "webrtc/common_video/include/video_bitrate_allocator.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/base/criticalsection.h"
#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
#include "webrtc/modules/video_coding/encoded_frame.h"
#include "webrtc/modules/video_coding/include/video_codec_initializer.h"
#include "webrtc/modules/video_coding/include/video_codec_interface.h"
#include "webrtc/modules/video_coding/encoded_frame.h"
#include "webrtc/modules/video_coding/jitter_buffer.h"
#include "webrtc/modules/video_coding/packet.h"
#include "webrtc/modules/video_coding/timing.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
@ -84,9 +85,11 @@ class VideoCodingModuleImpl : public VideoCodingModule {
EncodedImageCallback* pre_decode_image_callback)
: VideoCodingModule(),
sender_(clock, &post_encode_callback_, nullptr),
timing_(new VCMTiming(clock)),
receiver_(clock,
event_factory,
pre_decode_image_callback,
timing_.get(),
nack_sender,
keyframe_request_sender) {}
@ -277,6 +280,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
EncodedImageCallbackWrapper post_encode_callback_;
vcm::VideoSender sender_;
std::unique_ptr<VideoBitrateAllocator> rate_allocator_;
std::unique_ptr<VCMTiming> timing_;
vcm::VideoReceiver receiver_;
};
} // namespace

3
webrtc/modules/video_coding/video_coding_impl.h
View File

@ -148,6 +148,7 @@ class VideoReceiver : public Module {
VideoReceiver(Clock* clock,
EventFactory* event_factory,
EncodedImageCallback* pre_decode_image_callback,
VCMTiming* timing,
NackSender* nack_sender = nullptr,
KeyFrameRequestSender* keyframe_request_sender = nullptr);
~VideoReceiver();
@ -208,7 +209,7 @@ class VideoReceiver : public Module {
Clock* const clock_;
rtc::CriticalSection process_crit_;
rtc::CriticalSection receive_crit_;
VCMTiming _timing;
VCMTiming* _timing;
VCMReceiver _receiver;
VCMDecodedFrameCallback _decodedFrameCallback;
VCMFrameTypeCallback* _frameTypeCallback GUARDED_BY(process_crit_);

17
webrtc/modules/video_coding/video_receiver.cc
View File

@ -26,16 +26,17 @@ namespace vcm {
VideoReceiver::VideoReceiver(Clock* clock,
EventFactory* event_factory,
EncodedImageCallback* pre_decode_image_callback,
VCMTiming* timing,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender)
: clock_(clock),
_timing(clock_),
_receiver(&_timing,
_timing(timing),
_receiver(_timing,
clock_,
event_factory,
nack_sender,
keyframe_request_sender),
_decodedFrameCallback(&_timing, clock_),
_decodedFrameCallback(_timing, clock_),
_frameTypeCallback(nullptr),
_receiveStatsCallback(nullptr),
_decoderTimingCallback(nullptr),
@ -73,7 +74,7 @@ void VideoReceiver::Process() {
int jitter_buffer_ms;
int min_playout_delay_ms;
int render_delay_ms;
_timing.GetTimings(&decode_ms, &max_decode_ms, &current_delay_ms,
_timing->GetTimings(&decode_ms, &max_decode_ms, &current_delay_ms,
&target_delay_ms, &jitter_buffer_ms,
&min_playout_delay_ms, &render_delay_ms);
_decoderTimingCallback->OnDecoderTiming(
@ -276,7 +277,7 @@ int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
rtc::CritScope cs(&receive_crit_);
// If this frame was too late, we should adjust the delay accordingly
_timing.UpdateCurrentDelay(frame->RenderTimeMs(),
_timing->UpdateCurrentDelay(frame->RenderTimeMs(),
clock_->TimeInMilliseconds());
if (first_frame_received_()) {
@ -440,20 +441,20 @@ int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload,
// to sync with audio. Not included in VideoCodingModule::Delay()
// Defaults to 0 ms.
int32_t VideoReceiver::SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) {
_timing.set_min_playout_delay(minPlayoutDelayMs);
_timing->set_min_playout_delay(minPlayoutDelayMs);
return VCM_OK;
}
// The estimated delay caused by rendering, defaults to
// kDefaultRenderDelayMs = 10 ms
int32_t VideoReceiver::SetRenderDelay(uint32_t timeMS) {
_timing.set_render_delay(timeMS);
_timing->set_render_delay(timeMS);
return VCM_OK;
}
// Current video delay
int32_t VideoReceiver::Delay() const {
return _timing.TargetVideoDelay();
return _timing->TargetVideoDelay();
}
uint32_t VideoReceiver::DiscardedPackets() const {

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

@ -15,6 +15,7 @@
#include "webrtc/modules/video_coding/include/mock/mock_video_codec_interface.h"
#include "webrtc/modules/video_coding/include/video_coding.h"
#include "webrtc/modules/video_coding/test/test_util.h"
#include "webrtc/modules/video_coding/timing.h"
#include "webrtc/modules/video_coding/video_coding_impl.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/test/gtest.h"
@ -33,7 +34,9 @@ class TestVideoReceiver : public ::testing::Test {
TestVideoReceiver() : clock_(0) {}
virtual void SetUp() {
receiver_.reset(new VideoReceiver(&clock_, &event_factory_, nullptr));
timing_.reset(new VCMTiming(&clock_));
receiver_.reset(
new VideoReceiver(&clock_, &event_factory_, nullptr, timing_.get()));
receiver_->RegisterExternalDecoder(&decoder_, kUnusedPayloadType);
const size_t kMaxNackListSize = 250;
const int kMaxPacketAgeToNack = 450;
@ -75,6 +78,7 @@ class TestVideoReceiver : public ::testing::Test {
NiceMock<MockVideoDecoder> decoder_;
NiceMock<MockPacketRequestCallback> packet_request_callback_;
std::unique_ptr<VCMTiming> timing_;
std::unique_ptr<VideoReceiver> receiver_;
};

4
webrtc/video/video_receive_stream.cc
View File

@ -203,9 +203,9 @@ VideoReceiveStream::VideoReceiveStream(
decode_thread_(DecodeThreadFunction, this, "DecodingThread"),
congestion_controller_(congestion_controller),
call_stats_(call_stats),
video_receiver_(clock_, nullptr, this, this, this),
stats_proxy_(&config_, clock_),
timing_(new VCMTiming(clock_)),
video_receiver_(clock_, nullptr, this, timing_.get(), this, this),
stats_proxy_(&config_, clock_),
rtp_stream_receiver_(
&video_receiver_,
congestion_controller_->GetRemoteBitrateEstimator(

2
webrtc/video/video_receive_stream.h
View File

@ -118,10 +118,10 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
CongestionController* const congestion_controller_;
CallStats* const call_stats_;
std::unique_ptr<VCMTiming> timing_; // Jitter buffer experiment.
vcm::VideoReceiver video_receiver_;
std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> incoming_video_stream_;
ReceiveStatisticsProxy stats_proxy_;
std::unique_ptr<VCMTiming> timing_; // Jitter buffer experiment.
RtpStreamReceiver rtp_stream_receiver_;
std::unique_ptr<VideoStreamDecoder> video_stream_decoder_;
RtpStreamsSynchronizer rtp_stream_sync_;