Apply VideoOptions per stream.

talk/media/webrtc/webrtcvideoengine2.h

 /*
  * libjingle
  * Copyright 2014 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 184 matching lines @@
   uint32_t GetDefaultSendChannelSsrc() { return default_send_ssrc_; }
 
  private:
   bool MuteStream(uint32_t ssrc, bool mute);
   class WebRtcVideoReceiveStream;
 
   bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
   bool SetSendRtpHeaderExtensions(
       const std::vector<RtpHeaderExtension>& extensions);
   bool SetMaxSendBandwidth(int bps);
-  bool SetOptions(const VideoOptions& options);
+  void SetSharedOptions(const VideoOptions& options);
+  bool SetOptions(uint32_t ssrc, const VideoOptions& options);
   bool SetRecvCodecs(const std::vector<VideoCodec>& codecs);
   bool SetRecvRtpHeaderExtensions(
       const std::vector<RtpHeaderExtension>& extensions);
 
   void ConfigureReceiverRtp(webrtc::VideoReceiveStream::Config* config,
                             const StreamParams& sp) const;
   bool CodecIsExternallySupported(const std::string& name) const;
   bool ValidateSendSsrcAvailability(const StreamParams& sp) const
       EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
   bool ValidateReceiveSsrcAvailability(const StreamParams& sp) const
@@ skipping 17 matching lines @@
 
   // Wrapper for the sender part, this is where the capturer is connected and
   // frames are then converted from cricket frames to webrtc frames.
   class WebRtcVideoSendStream : public sigslot::has_slots<> {
    public:
     WebRtcVideoSendStream(
         webrtc::Call* call,
         const StreamParams& sp,
         const webrtc::VideoSendStream::Config& config,
         WebRtcVideoEncoderFactory* external_encoder_factory,
-        const VideoOptions& options,
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings,
         const std::vector<webrtc::RtpExtension>& rtp_extensions,
         const VideoSendParameters& send_params);
     ~WebRtcVideoSendStream();
 
     void SetOptions(const VideoOptions& options);
     void SetCodec(const VideoCodecSettings& codec);
     void SetRtpExtensions(
         const std::vector<webrtc::RtpExtension>& rtp_extensions);
@@ skipping 205 matching lines @@
     // the stream has been running.
     rtc::TimestampWrapAroundHandler timestamp_wraparound_handler_
         GUARDED_BY(renderer_lock_);
     int64_t first_frame_timestamp_ GUARDED_BY(renderer_lock_);
     // Start NTP time is estimated as current remote NTP time (estimated from
     // RTCP) minus the elapsed time, as soon as remote NTP time is available.
     int64_t estimated_remote_start_ntp_time_ms_ GUARDED_BY(renderer_lock_);
   };
 
   void Construct(webrtc::Call* call, WebRtcVideoEngine2* engine);
-  void SetDefaultOptions();
 
   bool SendRtp(const uint8_t* data,
                size_t len,
                const webrtc::PacketOptions& options) override;
   bool SendRtcp(const uint8_t* data, size_t len) override;
 
   void StartAllSendStreams();
   void StopAllSendStreams();
 
   static std::vector<VideoCodecSettings> MapCodecs(
@@ skipping 18 matching lines @@
 
   DefaultUnsignalledSsrcHandler default_unsignalled_ssrc_handler_;
   UnsignalledSsrcHandler* const unsignalled_ssrc_handler_;
 
   // Separate list of set capturers used to signal CPU adaptation. These should
   // not be locked while calling methods that take other locks to prevent
   // lock-order inversions.
   rtc::CriticalSection capturer_crit_;
   bool signal_cpu_adaptation_ GUARDED_BY(capturer_crit_);
   std::map<uint32_t, VideoCapturer*> capturers_ GUARDED_BY(capturer_crit_);
+  bool disable_prerenderer_smoothing_;
 
   rtc::CriticalSection stream_crit_;
   // Using primary-ssrc (first ssrc) as key.
   std::map<uint32_t, WebRtcVideoSendStream*> send_streams_
       GUARDED_BY(stream_crit_);
   std::map<uint32_t, WebRtcVideoReceiveStream*> receive_streams_
       GUARDED_BY(stream_crit_);
   std::set<uint32_t> send_ssrcs_ GUARDED_BY(stream_crit_);
   std::set<uint32_t> receive_ssrcs_ GUARDED_BY(stream_crit_);
 
   rtc::Optional<VideoCodecSettings> send_codec_;
   std::vector<webrtc::RtpExtension> send_rtp_extensions_;
 
   WebRtcVideoEncoderFactory* const external_encoder_factory_;
   WebRtcVideoDecoderFactory* const external_decoder_factory_;
   std::vector<VideoCodecSettings> recv_codecs_;
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
   webrtc::Call::Config::BitrateConfig bitrate_config_;
-  VideoOptions options_;
   // TODO(deadbeef): Don't duplicate information between
   // send_params/recv_params, rtp_extensions, options, etc.
   VideoSendParameters send_params_;
   VideoRecvParameters recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_H_