Add field trial to update quality scaler QP thresholds for Android HW encoder.

webrtc/sdk/android/src/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 2015 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 68 matching lines @@
 #endif
 #define ALOGD LOG_TAG(rtc::LS_INFO, TAG_ENCODER)
 #define ALOGW LOG_TAG(rtc::LS_WARNING, TAG_ENCODER)
 #define ALOGE LOG_TAG(rtc::LS_ERROR, TAG_ENCODER)
 
 namespace {
 // Maximum time limit between incoming frames before requesting a key frame.
 const size_t kFrameDiffThresholdMs = 350;
 const int kMinKeyFrameInterval = 6;
 const char kH264HighProfileFieldTrial[] = "WebRTC-H264HighProfile";
+const char kCustomQPThresholdsFieldTrial[] = "WebRTC-CustomQPThresholds";
 }  // namespace
 
 // MediaCodecVideoEncoder is a webrtc::VideoEncoder implementation that uses
 // Android's MediaCodec SDK API behind the scenes to implement (hopefully)
 // HW-backed video encode.  This C++ class is implemented as a very thin shim,
 // delegating all of the interesting work to org.webrtc.MediaCodecVideoEncoder.
 // MediaCodecVideoEncoder must be operated on a single task queue, currently
 // this is the encoder queue from ViE encoder.
 class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
  public:
@@ skipping 74 matching lines @@
 
   // Deliver any outputs pending in the MediaCodec to our |callback_| and return
   // true on success.
   bool DeliverPendingOutputs(JNIEnv* jni);
 
   VideoEncoder::ScalingSettings GetScalingSettings() const override;
 
   // Displays encoder statistics.
   void LogStatistics(bool force_log);
 
+  VideoCodecType GetCodecType() const;

[kthelgason, 2017/03/22 07:38:58]

Thanks for cleaning this up!

+
 #if RTC_DCHECK_IS_ON
   // Mutex for protecting inited_. It is only used for correctness checking on
   // debug build. It is used for checking that encoder has been released in the
   // destructor. Because this might happen on a different thread, we need a
   // mutex.
   rtc::CriticalSection inited_crit_;
 #endif
 
   // Type of video codec.
   const cricket::VideoCodec codec_;
@@ skipping 184 matching lines @@
 int32_t MediaCodecVideoEncoder::InitEncode(
     const webrtc::VideoCodec* codec_settings,
     int32_t /* number_of_cores */,
     size_t /* max_payload_size */) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (codec_settings == NULL) {
     ALOGE << "NULL VideoCodec instance";
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
-  const VideoCodecType codec_type = webrtc::PayloadNameToCodecType(codec_.name)
-                                        .value_or(webrtc::kVideoCodecUnknown);
+  const VideoCodecType codec_type = GetCodecType();
   RTC_CHECK(codec_settings->codecType == codec_type)
       << "Unsupported codec " << codec_settings->codecType << " for "
       << codec_type;
   if (sw_fallback_required_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   codec_mode_ = codec_settings->mode;
   int init_width = codec_settings->width;
   int init_height = codec_settings->height;
   // Scaling is disabled for VP9, but optionally enabled for VP8.
@@ skipping 92 matching lines @@
   }
   return false;
 }
 
 int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncode() {
   ProcessHWError(true /* reset_if_fallback_unavailable */);
   return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE
                                : WEBRTC_VIDEO_CODEC_ERROR;
 }
 
+VideoCodecType MediaCodecVideoEncoder::GetCodecType() const {
+  return webrtc::PayloadNameToCodecType(codec_.name)
+      .value_or(webrtc::kVideoCodecUnknown);
+}
+
 int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
                                                    int height,
                                                    int kbps,
                                                    int fps,
                                                    bool use_surface) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (sw_fallback_required_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   RTC_CHECK(!use_surface || egl_context_ != nullptr) << "EGL context not set.";
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
-  const VideoCodecType codec_type = webrtc::PayloadNameToCodecType(codec_.name)
-                                        .value_or(webrtc::kVideoCodecUnknown);
+  const VideoCodecType codec_type = GetCodecType();
   ALOGD << "InitEncodeInternal Type: " << (int)codec_type << ", " << width
         << " x " << height << ". Bitrate: " << kbps << " kbps. Fps: " << fps;
   if (kbps == 0) {
     kbps = last_set_bitrate_kbps_;
   }
   if (fps == 0) {
     fps = MAX_VIDEO_FPS;
   }
 
   width_ = width;
@@ skipping 489 matching lines @@
     size_t payload_size = jni->GetDirectBufferCapacity(j_output_buffer);
     uint8_t* payload = reinterpret_cast<uint8_t*>(
         jni->GetDirectBufferAddress(j_output_buffer));
     if (CheckException(jni)) {
       ALOGE << "Exception in get direct buffer address.";
       ProcessHWError(true /* reset_if_fallback_unavailable */);
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     // Callback - return encoded frame.
-    const VideoCodecType codec_type =
-        webrtc::PayloadNameToCodecType(codec_.name)
-            .value_or(webrtc::kVideoCodecUnknown);
+    const VideoCodecType codec_type = GetCodecType();
     webrtc::EncodedImageCallback::Result callback_result(
         webrtc::EncodedImageCallback::Result::OK);
     if (callback_) {
       std::unique_ptr<webrtc::EncodedImage> image(
           new webrtc::EncodedImage(payload, payload_size, payload_size));
       image->_encodedWidth = width_;
       image->_encodedHeight = height_;
       image->_timeStamp = output_timestamp_;
       image->capture_time_ms_ = output_render_time_ms_;
       image->rotation_ = output_rotation_;
@@ skipping 141 matching lines @@
     stat_start_time_ms_ = rtc::TimeMillis();
     current_frames_ = 0;
     current_bytes_ = 0;
     current_acc_qp_ = 0;
     current_encoding_time_ms_ = 0;
   }
 }
 
 webrtc::VideoEncoder::ScalingSettings
 MediaCodecVideoEncoder::GetScalingSettings() const {
+  if (webrtc::field_trial::IsEnabled(kCustomQPThresholdsFieldTrial)) {
+    const VideoCodecType codec_type = GetCodecType();
+    std::string experiment_string =
+        webrtc::field_trial::FindFullName(kCustomQPThresholdsFieldTrial);
+    ALOGD << "QP custom thresholds: " << experiment_string << " for codec "

[stefan-webrtc, 2017/03/23 17:58:04]

LOG(LS_INFO) or similar?

[AlexG, 2017/03/23 19:25:08]

ALOGD is used now for all logging in this file - this was done to use custom TAG
for both Java and JNI code for easier filtering in logcat. May be moving to
LOG(LS_INFO) will make sense, but then we need to change all logging on this
file. This is probably out of scope for this CL.

+          << codec_type;
+    int lowVp8QpThreshold;
+    int highVp8QpThreshold;
+    int lowH264QpThreshold;
+    int highH264QpThreshold;

[stefan-webrtc, 2017/03/23 17:58:04]

No camelCase

[AlexG, 2017/03/23 19:25:08]

Done.

+    int parsed_values = sscanf(experiment_string.c_str(), "Enabled-%u,%u,%u,%u",
+                               &lowVp8QpThreshold, &highVp8QpThreshold,
+                               &lowH264QpThreshold, &highH264QpThreshold);
+    if (parsed_values == 4) {
+      RTC_CHECK_GT(highVp8QpThreshold, lowVp8QpThreshold);
+      RTC_CHECK_GT(lowVp8QpThreshold, 0);
+      RTC_CHECK_GT(highH264QpThreshold, lowH264QpThreshold);
+      RTC_CHECK_GT(lowH264QpThreshold, 0);
+      if (codec_type == kVideoCodecVP8) {
+        return VideoEncoder::ScalingSettings(scale_, lowVp8QpThreshold,
+                                             highVp8QpThreshold);
+      } else if (codec_type == kVideoCodecH264) {
+        return VideoEncoder::ScalingSettings(scale_, lowH264QpThreshold,
+                                             highH264QpThreshold);
+      }
+    }
+  }
   return VideoEncoder::ScalingSettings(scale_);
 }
 
 const char* MediaCodecVideoEncoder::ImplementationName() const {
   return "MediaCodec";
 }
 
 MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
     : egl_context_(nullptr) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
@@ skipping 112 matching lines @@
   }
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni