Avoid unnecessary HW video encoder reconfiguration

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 378 matching lines @@
   return GetSimulcastConfig(
       num_streams, codec.width, codec.height, max_bitrate_bps, max_qp,
       codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
 }
 
 std::vector<webrtc::VideoStream>
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
     const VideoCodec& codec,
     const VideoOptions& options,
     int max_bitrate_bps,
-    size_t num_streams) {
+    size_t num_streams,
+    bool encode_from_texture) {
   int codec_max_bitrate_kbps;
   if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
     max_bitrate_bps = codec_max_bitrate_kbps * 1000;
   }
   if (num_streams != 1) {
     return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
                                        num_streams);
   }
 
   // For unset max bitrates set default bitrate for non-simulcast.
   if (max_bitrate_bps <= 0) {
     max_bitrate_bps =
         GetMaxDefaultVideoBitrateKbps(codec.width, codec.height) * 1000;
   }
 
   webrtc::VideoStream stream;
   stream.width = codec.width;
   stream.height = codec.height;
   stream.max_framerate =
       codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
 
   stream.min_bitrate_bps = kMinVideoBitrate * 1000;
   stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
 
   int max_qp = kDefaultQpMax;
   codec.GetParam(kCodecParamMaxQuantization, &max_qp);
   stream.max_qp = max_qp;
+  stream.encode_from_texture = encode_from_texture;
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
     const VideoCodec& codec) {
   bool is_screencast = parameters_.options.is_screencast.value_or(false);
   // No automatic resizing when using simulcast or screencast.
   bool automatic_resize =
@@ skipping 304 matching lines @@
   }
 
   if (!send_codec_ || supported_codecs.front() != *send_codec_) {
     changed_params->codec =
         rtc::Optional<VideoCodecSettings>(supported_codecs.front());
   }
 
   // Handle RTP header extensions.
   std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
       params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true);
-  if (send_rtp_extensions_ != filtered_extensions) {
+  if (!send_rtp_extensions_ || (*send_rtp_extensions_ != filtered_extensions)) {
     changed_params->rtp_header_extensions =
         rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
   }
 
   // Handle max bitrate.
   if (params.max_bandwidth_bps != send_params_.max_bandwidth_bps &&
       params.max_bandwidth_bps >= 0) {
     // 0 uncaps max bitrate (-1).
     changed_params->max_bandwidth_bps = rtc::Optional<int>(
         params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps);
@@ skipping 27 matching lines @@
     return false;
   }
 
   if (changed_params.codec) {
     const VideoCodecSettings& codec_settings = *changed_params.codec;
     send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings);
     LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString();
   }
 
   if (changed_params.rtp_header_extensions) {
-    send_rtp_extensions_ = *changed_params.rtp_header_extensions;
+    send_rtp_extensions_ = changed_params.rtp_header_extensions;
   }
 
   if (changed_params.codec || changed_params.max_bandwidth_bps) {
     if (send_codec_) {
       // TODO(holmer): Changing the codec parameters shouldn't necessarily mean
       // that we change the min/max of bandwidth estimation. Reevaluate this.
       bitrate_config_ = GetBitrateConfigForCodec(send_codec_->codec);
       if (!changed_params.codec) {
         // If the codec isn't changing, set the start bitrate to -1 which means
         // "unchanged" so that BWE isn't affected.
@@ skipping 703 matching lines @@
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
     const StreamParams& sp,
     const webrtc::VideoSendStream::Config& config,
     const VideoOptions& options,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     bool enable_cpu_overuse_detection,
     int max_bitrate_bps,
     const rtc::Optional<VideoCodecSettings>& codec_settings,
-    const std::vector<webrtc::RtpExtension>& rtp_extensions,
+    const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,
     // TODO(deadbeef): Don't duplicate information between send_params,
     // rtp_extensions, options, etc.
     const VideoSendParameters& send_params)
     : worker_thread_(rtc::Thread::Current()),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       cpu_restricted_counter_(0),
       number_of_cpu_adapt_changes_(0),
       source_(nullptr),
       external_encoder_factory_(external_encoder_factory),
       stream_(nullptr),
       parameters_(config, options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false),
       sending_(false),
       last_frame_timestamp_ms_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
   parameters_.conference_mode = send_params.conference_mode;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
   sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
                  &parameters_.config.rtp.rtx.ssrcs);
   parameters_.config.rtp.c_name = sp.cname;
-  parameters_.config.rtp.extensions = rtp_extensions;
+  if (rtp_extensions) {
+    parameters_.config.rtp.extensions = *rtp_extensions;
+  }
   parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
                                          ? webrtc::RtcpMode::kReducedSize
                                          : webrtc::RtcpMode::kCompound;
   parameters_.config.overuse_callback =
       enable_cpu_overuse_detection ? this : nullptr;
 
-  sink_wants_.rotation_applied = !ContainsHeaderExtension(
-      rtp_extensions, webrtc::RtpExtension::kVideoRotationUri);
+  sink_wants_.rotation_applied =
+      rtp_extensions &&
+      !ContainsHeaderExtension(*rtp_extensions,
+                               webrtc::RtpExtension::kVideoRotationUri);
 
   if (codec_settings) {
     SetCodec(*codec_settings);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
   DisconnectSource();
   if (stream_ != NULL) {
     call_->DestroyVideoSendStream(stream_);
@@ skipping 18 matching lines @@
   frame.set_render_time_ms(render_time_ms_);
   return frame;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
     const VideoFrame& frame) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame");
   webrtc::VideoFrame video_frame(frame.video_frame_buffer(), 0, 0,
                                  frame.rotation());
   rtc::CritScope cs(&lock_);
+
+  last_rotation_ = video_frame.rotation();
+  last_frame_in_texture_ =
+      video_frame.video_frame_buffer()->native_handle() != NULL;
+  if (video_frame.width() != last_dimensions_.width ||
+      video_frame.height() != last_dimensions_.height) {
+    last_dimensions_.width = video_frame.width();
+    last_dimensions_.height = video_frame.height();
+    pending_encoder_reconfiguration_ = true;
+    LOG(LS_INFO) << "Caching frame dimensions: " << last_dimensions_.width
+                 << "x" << last_dimensions_.height << ", r=" << last_rotation_
+                 << ", texture=" << last_frame_in_texture_;
+  }
+
   if (stream_ == NULL) {
     // Frame input before send codecs are configured, dropping frame.
     return;
   }
 
   int64_t frame_delta_ms = frame.GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
 
   // frame->GetTimeStamp() is essentially a delta, align to webrtc time
   if (!first_frame_timestamp_ms_) {
     first_frame_timestamp_ms_ =
         rtc::Optional<int64_t>(rtc::TimeMillis() - frame_delta_ms);
   }
 
   last_frame_timestamp_ms_ = *first_frame_timestamp_ms_ + frame_delta_ms;
 
   video_frame.set_render_time_ms(last_frame_timestamp_ms_);
-  // Reconfigure codec if necessary.
-  SetDimensions(video_frame.width(), video_frame.height());
-  last_rotation_ = video_frame.rotation();
+
+  ReconfigureEncoderIfNecessary();
 
   // Not sending, abort after reconfiguration. Reconfiguration should still
   // occur to permit sending this input as quickly as possible once we start
   // sending (without having to reconfigure then).
   if (!sending_) {
     return;
   }
 
   stream_->Input()->IncomingCapturedFrame(video_frame);
 }
@@ skipping 126 matching lines @@
 void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
     AllocatedEncoder* encoder) {
   if (encoder->external) {
     external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
   }
   delete encoder->encoder;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
     const VideoCodecSettings& codec_settings) {
-  parameters_.encoder_config =
-      CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
+  parameters_.encoder_config = CreateVideoEncoderConfig(
+      last_dimensions_, last_frame_in_texture_, codec_settings.codec);
   RTC_DCHECK(!parameters_.encoder_config.streams.empty());
 
   AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
   parameters_.config.encoder_settings.encoder = new_encoder.encoder;
   parameters_.config.encoder_settings.full_overuse_time = new_encoder.external;
   parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
   parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
   if (new_encoder.external) {
     webrtc::VideoCodecType type = CodecTypeFromName(codec_settings.codec.name);
     parameters_.config.encoder_settings.internal_source =
@@ skipping 119 matching lines @@
   } else {
     if (stream_ != nullptr) {
       stream_->Stop();
     }
   }
 }
 
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const Dimensions& dimensions,
+    bool encode_from_texture,
     const VideoCodec& codec) const {
   webrtc::VideoEncoderConfig encoder_config;
   bool is_screencast = parameters_.options.is_screencast.value_or(false);
   if (is_screencast) {
     encoder_config.min_transmit_bitrate_bps =
         1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0);
     encoder_config.content_type =
         webrtc::VideoEncoderConfig::ContentType::kScreen;
   } else {
     encoder_config.min_transmit_bitrate_bps = 0;
@@ skipping 19 matching lines @@
   // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
   // or a screencast, only configure a single stream.
   size_t stream_count = parameters_.config.rtp.ssrcs.size();
   if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) {
     stream_count = 1;
   }
 
   int stream_max_bitrate =
       MinPositive(rtp_parameters_.encodings[0].max_bitrate_bps,
                   parameters_.max_bitrate_bps);
-  encoder_config.streams = CreateVideoStreams(
-      clamped_codec, parameters_.options, stream_max_bitrate, stream_count);
+  encoder_config.streams =
+      CreateVideoStreams(clamped_codec, parameters_.options, stream_max_bitrate,
+                         stream_count, encode_from_texture);
 
   // Conference mode screencast uses 2 temporal layers split at 100kbit.
   if (parameters_.conference_mode && is_screencast &&
       encoder_config.streams.size() == 1) {
     ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
 
     // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
     // on the VideoCodec struct as target and max bitrates, respectively.
     // See eg. webrtc::VP8EncoderImpl::SetRates().
     encoder_config.streams[0].target_bitrate_bps =
         config.tl0_bitrate_kbps * 1000;
     encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
     encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
     encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
         config.tl0_bitrate_kbps * 1000);
   }
   if (CodecNamesEq(codec.name, kVp9CodecName) && !is_screencast &&
       encoder_config.streams.size() == 1) {
     encoder_config.streams[0].temporal_layer_thresholds_bps.resize(
         GetDefaultVp9TemporalLayers() - 1);
   }
   return encoder_config;
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
-    int width,
-    int height) {
-  if (last_dimensions_.width == width && last_dimensions_.height == height &&
-      !pending_encoder_reconfiguration_) {
+void WebRtcVideoChannel2::WebRtcVideoSendStream::
+    ReconfigureEncoderIfNecessary() {
+  if (!pending_encoder_reconfiguration_) {
     // Configured using the same parameters, do not reconfigure.
     return;
   }
 
-  last_dimensions_.width = width;
-  last_dimensions_.height = height;
-
   RTC_DCHECK(!parameters_.encoder_config.streams.empty());
 
   RTC_CHECK(parameters_.codec_settings);
   VideoCodecSettings codec_settings = *parameters_.codec_settings;
 
-  webrtc::VideoEncoderConfig encoder_config =
-      CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
+  webrtc::VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(
+      last_dimensions_, last_frame_in_texture_, codec_settings.codec);
 
   encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
       codec_settings.codec);
 
   stream_->ReconfigureVideoEncoder(encoder_config);
 
   encoder_config.encoder_specific_settings = NULL;
   pending_encoder_reconfiguration_ = false;
 
   parameters_.encoder_config = encoder_config;
@@ skipping 617 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket