Remove field trial for scaling down MediaCodec.

webrtc/api/java/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 224 matching lines @@
   int64_t output_render_time_ms_; // Last output frame render time from
                                   // render_times_ms_ queue.
   // Frame size in bytes fed to MediaCodec.
   int yuv_size_;
   // True only when between a callback_->Encoded() call return a positive value
   // and the next Encode() call being ignored.
   bool drop_next_input_frame_;
   // Global references; must be deleted in Release().
   std::vector<jobject> input_buffers_;
   QualityScaler quality_scaler_;
-  // Dynamic resolution change, off by default.
-  bool scale_;
 
   // H264 bitstream parser, used to extract QP from encoded bitstreams.
   webrtc::H264BitstreamParser h264_bitstream_parser_;
 
   // VP9 variables to populate codec specific structure.
   webrtc::GofInfoVP9 gof_; // Contains each frame's temporal information for
                            // non-flexible VP9 mode.
   uint8_t tl0_pic_idx_;
   size_t gof_idx_;
 
@@ skipping 101 matching lines @@
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
   RTC_CHECK(codec_settings->codecType == codecType_)
       << "Unsupported codec " << codec_settings->codecType << " for "
       << codecType_;
 
   codec_mode_ = codec_settings->mode;
   int init_width = codec_settings->width;
   int init_height = codec_settings->height;
-  scale_ = (codecType_ != kVideoCodecVP9) && (webrtc::field_trial::FindFullName(
-        "WebRTC-MediaCodecVideoEncoder-AutomaticResize") == "Enabled");
+  ALOGD << "InitEncode request: " << init_width << " x " << init_height;
 
-  ALOGD << "InitEncode request: " << init_width << " x " << init_height;
-  ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled");
-
-  if (scale_) {
-    if (codecType_ == kVideoCodecVP8) {
-      // QP is obtained from VP8-bitstream for HW, so the QP corresponds to the
-      // (internal) range: [0, 127]. And we cannot change QP_max in HW, so it is
-      // always = 127. Note that in SW, QP is that of the user-level range [0,
-      // 63].
-      const int kLowQpThreshold = 29;
-      const int kBadQpThreshold = 90;
-      quality_scaler_.Init(kLowQpThreshold, kBadQpThreshold, false,
-                           codec_settings->startBitrate, codec_settings->width,
-                           codec_settings->height,
-                           codec_settings->maxFramerate);
-    } else if (codecType_ == kVideoCodecH264) {
-      // H264 QP is in the range [0, 51].
-      const int kLowQpThreshold = 21;
-      const int kBadQpThreshold = 33;
-      quality_scaler_.Init(kLowQpThreshold, kBadQpThreshold, false,
-                           codec_settings->startBitrate, codec_settings->width,
-                           codec_settings->height,
-                           codec_settings->maxFramerate);
-    } else {
-      // When adding codec support to additional hardware codecs, also configure
-      // their QP thresholds for scaling.
-      RTC_NOTREACHED() << "Unsupported codec without configured QP thresholds.";
-      scale_ = false;
-    }
-    quality_scaler_.SetMinResolution(kMinDimension, kMinDimension);
-    QualityScaler::Resolution res = quality_scaler_.GetScaledResolution();
-    init_width = std::max(res.width, kMinDimension);
-    init_height = std::max(res.height, kMinDimension);
-    ALOGD << "Scaled resolution: " << init_width << " x " << init_height;
+  if (codecType_ == kVideoCodecVP8) {
+    // QP is obtained from VP8-bitstream for HW, so the QP corresponds to the
+    // (internal) range: [0, 127]. And we cannot change QP_max in HW, so it is
+    // always = 127. Note that in SW, QP is that of the user-level range [0,
+    // 63].
+    const int kLowQpThreshold = 29;
+    const int kBadQpThreshold = 90;
+    quality_scaler_.Init(kLowQpThreshold, kBadQpThreshold, false,
+                         codec_settings->startBitrate, codec_settings->width,
+                         codec_settings->height, codec_settings->maxFramerate);
+  } else if (codecType_ == kVideoCodecH264) {
+    // H264 QP is in the range [0, 51].
+    const int kLowQpThreshold = 21;
+    const int kBadQpThreshold = 33;
+    quality_scaler_.Init(kLowQpThreshold, kBadQpThreshold, false,
+                         codec_settings->startBitrate, codec_settings->width,
+                         codec_settings->height, codec_settings->maxFramerate);
+  } else {
+    // When adding codec support to additional hardware codecs, also configure
+    // their QP thresholds for scaling.
+    RTC_NOTREACHED() << "Unsupported codec without configured QP thresholds.";
   }
+  quality_scaler_.SetMinResolution(kMinDimension, kMinDimension);
+  QualityScaler::Resolution res = quality_scaler_.GetScaledResolution();
+  init_width = std::max(res.width, kMinDimension);
+  init_height = std::max(res.height, kMinDimension);
+  ALOGD << "Scaled resolution: " << init_width << " x " << init_height;
 
   return codec_thread_->Invoke<int32_t>(
       Bind(&MediaCodecVideoEncoder::InitEncodeOnCodecThread,
            this,
            init_width,
            init_height,
            codec_settings->startBitrate,
            codec_settings->maxFramerate,
            false /* use_surface */));
 }
@@ skipping 239 matching lines @@
       ResetCodecOnCodecThread();
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
     frames_dropped_media_encoder_++;
     OnDroppedFrame();
     return WEBRTC_VIDEO_CODEC_OK;
   }
   consecutive_full_queue_frame_drops_ = 0;
 
   VideoFrame input_frame = frame;
-  if (scale_) {
-    // Check framerate before spatial resolution change.
-    quality_scaler_.OnEncodeFrame(frame);
-    const webrtc::QualityScaler::Resolution scaled_resolution =
-        quality_scaler_.GetScaledResolution();
-    if (scaled_resolution.width != frame.width() ||
-        scaled_resolution.height != frame.height()) {
-      if (frame.native_handle() != nullptr) {
-        rtc::scoped_refptr<webrtc::VideoFrameBuffer> scaled_buffer(
-            static_cast<AndroidTextureBuffer*>(
-                frame.video_frame_buffer().get())->ScaleAndRotate(
-                    scaled_resolution.width,
-                    scaled_resolution.height,
-                    webrtc::kVideoRotation_0));
-        input_frame.set_video_frame_buffer(scaled_buffer);
-      } else {
-        input_frame = quality_scaler_.GetScaledFrame(frame);
-      }
+  // Check framerate before spatial resolution change.
+  quality_scaler_.OnEncodeFrame(frame);
+  const webrtc::QualityScaler::Resolution scaled_resolution =

[AlexG, 2016/04/13 16:46:12]

How this will work for VP9 case? We do not report QP values to quality scaler
for VP9 codec - can it result in always downscaling to VGA for 720p input?

+      quality_scaler_.GetScaledResolution();
+  if (scaled_resolution.width != frame.width() ||
+      scaled_resolution.height != frame.height()) {
+    if (frame.native_handle() != nullptr) {
+      rtc::scoped_refptr<webrtc::VideoFrameBuffer> scaled_buffer(
+          static_cast<AndroidTextureBuffer*>(frame.video_frame_buffer().get())
+              ->ScaleAndRotate(scaled_resolution.width,
+                               scaled_resolution.height,
+                               webrtc::kVideoRotation_0));
+      input_frame.set_video_frame_buffer(scaled_buffer);
+    } else {
+      input_frame = quality_scaler_.GetScaledFrame(frame);
     }
   }
 
   if (!MaybeReconfigureEncoderOnCodecThread(input_frame)) {
     ALOGE << "Failed to reconfigure encoder.";
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   // Save time when input frame is sent to the encoder input.
   frame_rtc_times_ms_.push_back(GetCurrentTimeMs());
@@ skipping 160 matching lines @@
 
 int32_t MediaCodecVideoEncoder::SetRatesOnCodecThread(uint32_t new_bit_rate,
                                                       uint32_t frame_rate) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   frame_rate = (frame_rate < MAX_ALLOWED_VIDEO_FPS) ?
       frame_rate : MAX_ALLOWED_VIDEO_FPS;
   if (last_set_bitrate_kbps_ == new_bit_rate &&
       last_set_fps_ == frame_rate) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
-  if (scale_) {
-    quality_scaler_.ReportFramerate(frame_rate);
-  }
+  quality_scaler_.ReportFramerate(frame_rate);
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   if (new_bit_rate > 0) {
     last_set_bitrate_kbps_ = new_bit_rate;
   }
   if (frame_rate > 0) {
     last_set_fps_ = frame_rate;
   }
   bool ret = jni->CallBooleanMethod(*j_media_codec_video_encoder_,
                                        j_set_rates_method_,
@@ skipping 92 matching lines @@
       scoped_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->_frameType =
           (key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta);
       image->_completeFrame = true;
       image->adapt_reason_.quality_resolution_downscales =
-          scale_ ? quality_scaler_.downscale_shift() : -1;
+          quality_scaler_.downscale_shift();
 
       webrtc::CodecSpecificInfo info;
       memset(&info, 0, sizeof(info));
       info.codecType = codecType_;
       if (codecType_ == kVideoCodecVP8) {
         info.codecSpecific.VP8.pictureId = picture_id_;
         info.codecSpecific.VP8.nonReference = false;
         info.codecSpecific.VP8.simulcastIdx = 0;
         info.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx;
         info.codecSpecific.VP8.layerSync = false;
@@ skipping 27 matching lines @@
 
       // Generate a header describing a single fragment.
       webrtc::RTPFragmentationHeader header;
       memset(&header, 0, sizeof(header));
       if (codecType_ == kVideoCodecVP8 || codecType_ == kVideoCodecVP9) {
         header.VerifyAndAllocateFragmentationHeader(1);
         header.fragmentationOffset[0] = 0;
         header.fragmentationLength[0] = image->_length;
         header.fragmentationPlType[0] = 0;
         header.fragmentationTimeDiff[0] = 0;
-        if (codecType_ == kVideoCodecVP8 && scale_) {
+        if (codecType_ == kVideoCodecVP8) {
           int qp;
           if (webrtc::vp8::GetQp(payload, payload_size, &qp)) {
             current_acc_qp_ += qp;
             quality_scaler_.ReportQP(qp);
           }
         }
       } else if (codecType_ == kVideoCodecH264) {
-        if (scale_) {
-          h264_bitstream_parser_.ParseBitstream(payload, payload_size);
-          int qp;
-          if (h264_bitstream_parser_.GetLastSliceQp(&qp)) {
-            current_acc_qp_ += qp;
-            quality_scaler_.ReportQP(qp);
-          }
+        h264_bitstream_parser_.ParseBitstream(payload, payload_size);
+        int qp;
+        if (h264_bitstream_parser_.GetLastSliceQp(&qp)) {
+          current_acc_qp_ += qp;
+          quality_scaler_.ReportQP(qp);
         }
         // For H.264 search for start codes.
         int32_t scPositions[MAX_NALUS_PERFRAME + 1] = {};
         int32_t scPositionsLength = 0;
         int32_t scPosition = 0;
         while (scPositionsLength < MAX_NALUS_PERFRAME) {
           int32_t naluPosition = NextNaluPosition(
               payload + scPosition, payload_size - scPosition);
           if (naluPosition < 0) {
             break;
@@ skipping 99 matching lines @@
       head++; // xx != 1, continue searching.
       continue;
     }
     return (int32_t)(head - buffer);
   }
   return -1;
 }
 
 void MediaCodecVideoEncoder::OnDroppedFrame() {
   // Report dropped frame to quality_scaler_.
-  if (scale_)
-    quality_scaler_.ReportDroppedFrame();
+  quality_scaler_.ReportDroppedFrame();
 }
 
 int MediaCodecVideoEncoder::GetTargetFramerate() {
-  return scale_ ? quality_scaler_.GetTargetFramerate() : -1;
+  return quality_scaler_.GetTargetFramerate();
 }
 
 const char* MediaCodecVideoEncoder::ImplementationName() const {
   return "MediaCodec";
 }
 
 MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
     : egl_context_(nullptr) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
@@ skipping 77 matching lines @@
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni