1 clock_

Call* CallFactory::CreateCall(const Call::Config& config) {
  absl::optional<webrtc::BuiltInNetworkBehaviorConfig> send_degradation_config =
      ParseDegradationConfig(true);
  absl::optional<webrtc::BuiltInNetworkBehaviorConfig>
      receive_degradation_config = ParseDegradationConfig(false);

  if (send_degradation_config || receive_degradation_config) {
    return new DegradedCall(std::unique_ptr<Call>(Call::Create(config)),
                            send_degradation_config, receive_degradation_config,
                            config.task_queue_factory);
  }

  return Call::Create(config); // 
}


Call* Call::Create(const Call::Config& config) {
  return Create(config, Clock::GetRealTimeClock(), // 
                ProcessThread::Create("ModuleProcessThread"),
                ProcessThread::Create("PacerThread"));
}


										Clock* Clock::GetRealTimeClock() {
										#if defined(WINUWP)
										  static Clock* const clock = new WinUwpRealTimeClock();
										#elif defined(WEBRTC_WIN)
										  static Clock* const clock = new WindowsRealTimeClock();
										#elif defined(WEBRTC_POSIX)
										  static Clock* const clock = new UnixRealTimeClock(); // 
										#else
										  static Clock* const clock = nullptr;
										#endif
										  return clock;
										}
										
										// class RealTimeClock : public Clock
										
										class UnixRealTimeClock : public RealTimeClock {
										 public:
										  UnixRealTimeClock() {}
										
										  ~UnixRealTimeClock() override {}
										
										 protected:
										  timeval CurrentTimeVal() override {
										    struct timeval tv;
										    struct timezone tz;
										    tz.tz_minuteswest = 0;
										    tz.tz_dsttime = 0;
										    gettimeofday(&tv, &tz);
										    return tv;
										  }
										};


Call* Call::Create(const Call::Config& config,
                   Clock* clock,
                   std::unique_ptr<ProcessThread> call_thread,
                   std::unique_ptr<ProcessThread> pacer_thread) {
  RTC_DCHECK(config.task_queue_factory);
  return new internal::Call(
      clock, config, // 将 clock 传递到 webrtc::internal::Call 中
      std::make_unique<RtpTransportControllerSend>(
          clock, config.event_log, config.network_state_predictor_factory,
          config.network_controller_factory, config.bitrate_config,
          std::move(pacer_thread), config.task_queue_factory),
      std::move(call_thread), config.task_queue_factory);
}



webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
    webrtc::VideoReceiveStream::Config configuration) {
  TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
  RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);

  receive_side_cc_.SetSendPeriodicFeedback(
      SendPeriodicFeedback(configuration.rtp.extensions));

  RegisterRateObserver();

  VideoReceiveStream* receive_stream = new VideoReceiveStream(
      task_queue_factory_, &video_receiver_controller_, num_cpu_cores_,
      transport_send_ptr_->packet_router(), std::move(configuration),
      module_process_thread_.get(), call_stats_.get(), clock_); // clock_ 就是 webrtc::internal::Call 中的 clock_ 
      
      
VideoReceiveStream::VideoReceiveStream(
    TaskQueueFactory* task_queue_factory,
    RtpStreamReceiverControllerInterface* receiver_controller,
    int num_cpu_cores,
    PacketRouter* packet_router,
    VideoReceiveStream::Config config,
    ProcessThread* process_thread,
    CallStats* call_stats,
    Clock* clock, // 
    VCMTiming* timing)
    : task_queue_factory_(task_queue_factory),
      transport_adapter_(config.rtcp_send_transport),
      config_(std::move(config)),
      num_cpu_cores_(num_cpu_cores),
      process_thread_(process_thread),
      clock_(clock),
      call_stats_(call_stats),
      source_tracker_(clock_),
      stats_proxy_(&config_, clock_),
      rtp_receive_statistics_(ReceiveStatistics::Create(clock_)),
      timing_(timing),
      video_receiver_(clock_, timing_.get()),
      rtp_video_stream_receiver_(clock_, // 
                                 &transport_adapter_,
                                 call_stats,
                                 packet_router,
                                 &config_,
                                 rtp_receive_statistics_.get(),
                                 &stats_proxy_,
                                 process_thread_,
                                 this,     // NackSender
                                 nullptr,  // Use default KeyFrameRequestSender
                                 this,     // OnCompleteFrameCallback
                                 config_.frame_decryptor),
                                 

RtpVideoStreamReceiver::RtpVideoStreamReceiver(
    Clock* clock,
    Transport* transport,
    RtcpRttStats* rtt_stats,
    PacketRouter* packet_router,
    const VideoReceiveStream::Config* config,
    ReceiveStatistics* rtp_receive_statistics,
    ReceiveStatisticsProxy* receive_stats_proxy,
    ProcessThread* process_thread,
    NackSender* nack_sender,
    KeyFrameRequestSender* keyframe_request_sender,
    video_coding::OnCompleteFrameCallback* complete_frame_callback,
    rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor)
    : clock_(clock), // 
      config_(*config),
      packet_router_(packet_router),
      process_thread_(process_thread),
      ntp_estimator_(clock), // 
      rtp_header_extensions_(config_.rtp.extensions),
      rtp_receive_statistics_(rtp_receive_statistics),
      ulpfec_receiver_(UlpfecReceiver::Create(config->rtp.remote_ssrc,
                                              this,
                                              config->rtp.extensions)),
      receiving_(false),
      last_packet_log_ms_(-1),
      rtp_rtcp_(CreateRtpRtcpModule(clock, // 
                                    rtp_receive_statistics_,
                                    transport,
                                    rtt_stats,
                                    receive_stats_proxy,
                                    config_.rtp.local_ssrc)),
      complete_frame_callback_(complete_frame_callback),
      keyframe_request_sender_(keyframe_request_sender),
      // TODO(bugs.webrtc.org/10336): Let |rtcp_feedback_buffer_| communicate
      // directly with |rtp_rtcp_|.
      rtcp_feedback_buffer_(this, nack_sender, this),
      packet_buffer_(clock_, // 
                     kPacketBufferStartSize,
                     PacketBufferMaxSize(),
                     this),
      has_received_frame_(false),
      frames_decryptable_(false) {

2 timing_

VideoReceiveStream::VideoReceiveStream(
    TaskQueueFactory* task_queue_factory,
    RtpStreamReceiverControllerInterface* receiver_controller,
    int num_cpu_cores,
    PacketRouter* packet_router,
    VideoReceiveStream::Config config,
    ProcessThread* process_thread,
    CallStats* call_stats,
    Clock* clock)
    : VideoReceiveStream(task_queue_factory,
                         receiver_controller,
                         num_cpu_cores,
                         packet_router,
                         std::move(config),
                         process_thread,
                         call_stats,
                         clock,
                         new VCMTiming(clock)) {} // 创建 VCMTiming 

					// explicit VCMTiming(Clock* clock, VCMTiming* master_timing = NULL) 默认参数
					VCMTiming::VCMTiming(Clock* clock, VCMTiming* master_timing)
					    : clock_(clock),
					      master_(false),
					      ts_extrapolator_(),
					      codec_timer_(new VCMCodecTimer()),
					      render_delay_ms_(kDefaultRenderDelayMs),
					      min_playout_delay_ms_(0),
					      max_playout_delay_ms_(10000),
					      jitter_delay_ms_(0),
					      current_delay_ms_(0),
					      prev_frame_timestamp_(0),
					      timing_frame_info_(),
					      num_decoded_frames_(0) {
					  if (master_timing == NULL) {
					    master_ = true;
					    ts_extrapolator_ = new TimestampExtrapolator(clock_->TimeInMilliseconds()); // 
					  } else {
					    ts_extrapolator_ = master_timing->ts_extrapolator_;
					  }
					}

                     
                         
VideoReceiveStream::VideoReceiveStream(
    TaskQueueFactory* task_queue_factory,
    RtpStreamReceiverControllerInterface* receiver_controller,
    int num_cpu_cores,
    PacketRouter* packet_router,
    VideoReceiveStream::Config config,
    ProcessThread* process_thread,
    CallStats* call_stats,
    Clock* clock,
    VCMTiming* timing)
===>
      timing_(timing),
      video_receiver_(clock_, timing_.get()),
		  timing_->set_render_delay(config_.render_delay_ms);		
		  frame_buffer_.reset(
		      new video_coding::FrameBuffer(clock_, timing_.get(), &stats_proxy_));