Disable encoder scaling on iPhone4S.

webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.mm

 /*
  *  Copyright (c) 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.
  *
  */
 
 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.h"
 
 #if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #if defined(WEBRTC_IOS)
+#import "WebRTC/UIDevice+RTCDevice.h"
 #include "RTCUIApplication.h"
 #endif
 #include "libyuv/convert_from.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace internal {
 
@@ skipping 179 matching lines @@
 // .5 is set as a mininum to prevent overcompensating for large temporary
 // overshoots. We don't want to degrade video quality too badly.
 // .95 is set to prevent oscillations. When a lower bitrate is set on the
 // encoder than previously set, its output seems to have a brief period of
 // drastically reduced bitrate, so we want to avoid that. In steady state
 // conditions, 0.95 seems to give us better overall bitrate over long periods
 // of time.
 H264VideoToolboxEncoder::H264VideoToolboxEncoder()
     : callback_(nullptr),
       compression_session_(nullptr),
-      bitrate_adjuster_(Clock::GetRealTimeClock(), .5, .95) {}
+      bitrate_adjuster_(Clock::GetRealTimeClock(), .5, .95),
+      enable_scaling_(true) {
+#if defined(WEBRTC_IOS)
+  if ([UIDevice deviceType] == RTCDeviceTypeIPhone4S) {
+    enable_scaling_ = false;
+  }
+#endif
+}
 
 H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
   DestroyCompressionSession();
 }
 
 int H264VideoToolboxEncoder::InitEncode(const VideoCodec* codec_settings,
                                         int number_of_cores,
                                         size_t max_payload_size) {
   RTC_DCHECK(codec_settings);
   RTC_DCHECK_EQ(codec_settings->codecType, kVideoCodecH264);
+  width_ = codec_settings->width;
+  height_ = codec_settings->height;
   {
     rtc::CritScope lock(&quality_scaler_crit_);
     quality_scaler_.Init(QualityScaler::kLowH264QpThreshold,
                          QualityScaler::kBadH264QpThreshold,
                          codec_settings->startBitrate, codec_settings->width,
                          codec_settings->height, codec_settings->maxFramerate);
     QualityScaler::Resolution res = quality_scaler_.GetScaledResolution();
     // TODO(tkchin): We may need to enforce width/height dimension restrictions
     // to match what the encoder supports.
-    width_ = res.width;
-    height_ = res.height;
+    if (enable_scaling_) {
+      width_ = res.width;
+      height_ = res.height;
+    }
   }
   // We can only set average bitrate on the HW encoder.
   target_bitrate_bps_ = codec_settings->startBitrate;
   bitrate_adjuster_.SetTargetBitrateBps(target_bitrate_bps_);
 
   // TODO(tkchin): Try setting payload size via
   // kVTCompressionPropertyKey_MaxH264SliceBytes.
 
   return ResetCompressionSession();
 }
 
 rtc::scoped_refptr<VideoFrameBuffer>
 H264VideoToolboxEncoder::GetScaledBufferOnEncode(
     const rtc::scoped_refptr<VideoFrameBuffer>& frame) {
   rtc::CritScope lock(&quality_scaler_crit_);
   quality_scaler_.OnEncodeFrame(frame->width(), frame->height());
   if (!frame->native_handle())
     return quality_scaler_.GetScaledBuffer(frame);
 
   // Handle native (CVImageRef) scaling.
   const QualityScaler::Resolution res = quality_scaler_.GetScaledResolution();
-  if (res.width == frame->width() && res.height == frame->height())
+  if (!enable_scaling_ ||
+      (res.width == frame->width() && res.height == frame->height()))
     return frame;
   // TODO(magjed): Implement efficient CVImageRef -> CVImageRef scaling instead
   // of doing it via I420.
   return quality_scaler_.GetScaledBuffer(frame->NativeToI420Buffer());
 }
 
 int H264VideoToolboxEncoder::Encode(
     const VideoFrame& frame,
     const CodecSpecificInfo* codec_specific_info,
     const std::vector<FrameType>* frame_types) {
@@ skipping 354 matching lines @@
   if (result != 0) {
     LOG(LS_ERROR) << "Encode callback failed: " << result;
     return;
   }
   bitrate_adjuster_.Update(frame._size);
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)