Create VideoReceiver with external VCMTiming object.

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}

webrtc/modules/video_coding/video_coding_impl.cc

@@ -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

webrtc/modules/video_coding/video_coding_impl.h

@@ -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_);

webrtc/modules/video_coding/video_receiver.cc

@@ -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_),
+      _timing(timing),
-      _receiver(&_timing,
+      _receiver(_timing,
                 clock_,
                 event_factory,
                 nack_sender,
                 keyframe_request_sender),
-      _decodedFrameCallback(&_timing, clock_),
+      _decodedFrameCallback(_timing, clock_),
       _frameTypeCallback(nullptr),
       _receiveStatsCallback(nullptr),
       _decoderTimingCallback(nullptr),
@@ -73,9 +74,9 @@ 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,
+                          &target_delay_ms, &jitter_buffer_ms,
-                         &min_playout_delay_ms, &render_delay_ms);
+                          &min_playout_delay_ms, &render_delay_ms);
       _decoderTimingCallback->OnDecoderTiming(
           decode_ms, max_decode_ms, current_delay_ms, target_delay_ms,
           jitter_buffer_ms, min_playout_delay_ms, render_delay_ms);
@@ -276,8 +277,8 @@ 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());
+                              clock_->TimeInMilliseconds());
 
   if (first_frame_received_()) {
     LOG(LS_INFO) << "Received first "
@@ -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 {

webrtc/modules/video_coding/video_receiver_unittest.cc

@@ -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_;
 };
 

webrtc/video/video_receive_stream.cc

@@ -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(

webrtc/video/video_receive_stream.h

@@ -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_;