Remove frame time scheduing in IncomingVideoStream

talk/media/base/mediachannel.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 249 matching lines @@
     SetFrom(&system_low_adaptation_threshhold,
             change.system_low_adaptation_threshhold);
     SetFrom(&system_high_adaptation_threshhold,
             change.system_high_adaptation_threshhold);
     SetFrom(&dscp, change.dscp);
     SetFrom(&suspend_below_min_bitrate, change.suspend_below_min_bitrate);
     SetFrom(&unsignalled_recv_stream_limit,
             change.unsignalled_recv_stream_limit);
     SetFrom(&use_simulcast_adapter, change.use_simulcast_adapter);
     SetFrom(&screencast_min_bitrate, change.screencast_min_bitrate);
+    SetFrom(&renderer_can_schedule_frames, change.renderer_can_schedule_frames);
   }
 
   bool operator==(const VideoOptions& o) const {
     return adapt_input_to_cpu_usage == o.adapt_input_to_cpu_usage &&
            adapt_cpu_with_smoothing == o.adapt_cpu_with_smoothing &&
            video_adapt_third == o.video_adapt_third &&
            video_noise_reduction == o.video_noise_reduction &&
            video_start_bitrate == o.video_start_bitrate &&
            cpu_overuse_detection == o.cpu_overuse_detection &&
            cpu_underuse_threshold == o.cpu_underuse_threshold &&
            cpu_overuse_threshold == o.cpu_overuse_threshold &&
            cpu_underuse_encode_rsd_threshold ==
                o.cpu_underuse_encode_rsd_threshold &&
            cpu_overuse_encode_rsd_threshold ==
                o.cpu_overuse_encode_rsd_threshold &&
            cpu_overuse_encode_usage == o.cpu_overuse_encode_usage &&
            conference_mode == o.conference_mode &&
            process_adaptation_threshhold == o.process_adaptation_threshhold &&
            system_low_adaptation_threshhold ==
                o.system_low_adaptation_threshhold &&
            system_high_adaptation_threshhold ==
                o.system_high_adaptation_threshhold &&
            dscp == o.dscp &&
            suspend_below_min_bitrate == o.suspend_below_min_bitrate &&
            unsignalled_recv_stream_limit == o.unsignalled_recv_stream_limit &&
            use_simulcast_adapter == o.use_simulcast_adapter &&
-           screencast_min_bitrate == o.screencast_min_bitrate;
+           screencast_min_bitrate == o.screencast_min_bitrate &&
+           renderer_can_schedule_frames == o.renderer_can_schedule_frames;
   }
 
   std::string ToString() const {
     std::ostringstream ost;
     ost << "VideoOptions {";
     ost << ToStringIfSet("cpu adaption", adapt_input_to_cpu_usage);
     ost << ToStringIfSet("cpu adaptation smoothing", adapt_cpu_with_smoothing);
     ost << ToStringIfSet("video adapt third", video_adapt_third);
     ost << ToStringIfSet("noise reduction", video_noise_reduction);
     ost << ToStringIfSet("start bitrate", video_start_bitrate);
@@ skipping 65 matching lines @@
   rtc::Optional<bool> dscp;
   // Enable WebRTC suspension of video. No video frames will be sent when the
   // bitrate is below the configured minimum bitrate.
   rtc::Optional<bool> suspend_below_min_bitrate;
   // Limit on the number of early receive channels that can be created.
   rtc::Optional<int> unsignalled_recv_stream_limit;
   // Enable use of simulcast adapter.
   rtc::Optional<bool> use_simulcast_adapter;
   // Force screencast to use a minimum bitrate
   rtc::Optional<int> screencast_min_bitrate;
+  // Set to true if the renderer has an algorithm of frame selection.
+  // If the value is true, then WebRTC will hand over a frame as soon as
+  // possible without delay, and rendering smoothness is completely the duty
+  // of the renderer;
+  // If the value is false, then WebRTC is responsible to delay frame release
+  // in order to increase rendering smoothness.
+  rtc::Optional<bool> renderer_can_schedule_frames;

[pthatcher1, 2015/11/19 22:19:25]

I don't like this name very much.

The comment makes it seem like a better name would be. 
"disable_prerenderer_smoothing"(default false) or
"smooth_frames_before_renderer" (default true).

[qiangchen, 2015/11/20 17:54:06]

Done.

 
  private:
   template <typename T>
   static void SetFrom(rtc::Optional<T>* s, const rtc::Optional<T>& o) {
     if (o) {
       *s = o;
     }
   }
 };
 
@@ skipping 812 matching lines @@
   // Signal when the media channel is ready to send the stream. Arguments are:
   //     writable(bool)
   sigslot::signal1<bool> SignalReadyToSend;
   // Signal for notifying that the remote side has closed the DataChannel.
   sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_MEDIACHANNEL_H_