Delete AndroidVideoCapturer::FrameFactory.

webrtc/api/java/jni/androidvideocapturer_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 151 matching lines @@
                       &webrtc::AndroidVideoCapturer::OnCapturerStarted,
                       success);
 }
 
 void AndroidVideoCapturerJni::OnMemoryBufferFrame(void* video_frame,
                                                   int length,
                                                   int width,
                                                   int height,
                                                   int rotation,
                                                   int64_t timestamp_ns) {
-  const uint8_t* y_plane = static_cast<uint8_t*>(video_frame);
-  const uint8_t* vu_plane = y_plane + width * height;
+  RTC_DCHECK(rotation == 0 || rotation == 90 || rotation == 180 ||
+             rotation == 270);
+  rtc::CritScope cs(&capturer_lock_);
+
+  int adapted_width;
+  int adapted_height;
+  int crop_width;
+  int crop_height;
+  int crop_x;
+  int crop_y;
+
+  if (!capturer_->AdaptFrame(width, height, &adapted_width, &adapted_height,
+                             &crop_width, &crop_height, &crop_x, &crop_y)) {
+    return;
+  }
+
+  int rotated_width = crop_width;
+  int rotated_height = crop_height;
+
+  if (capturer_->apply_rotation() && (rotation == 90 || rotation == 270)) {
+    std::swap(adapted_width, adapted_height);
+    std::swap(rotated_width, rotated_height);
+  }
 
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
-      buffer_pool_.CreateBuffer(width, height);
-  libyuv::NV21ToI420(
-      y_plane, width,
-      vu_plane, width,
+      buffer_pool_.CreateBuffer(rotated_width, rotated_height);
+
+  const uint8_t* y_plane = static_cast<const uint8_t*>(video_frame);
+  const uint8_t* uv_plane = y_plane + width * height;
+
+  // Can only crop at even pixels.
+  crop_x &= ~1;

[magjed_webrtc, 2016/05/18 15:45:30]

The same is true for crop_y.

[nisse-webrtc, 2016/05/18 16:34:17]

Done.

+
+  libyuv::NV12ToI420Rotate(
+      y_plane + width * crop_y + crop_x, width,
+      uv_plane + width * crop_y + crop_x, width,

[magjed_webrtc, 2016/05/18 15:45:30]

crop_y is not used correctly, it should be roughly half that.
uv_stride = (width + 1) / 2 * 2;
uv_plane + uv_stride * (crop_y / 2) + crop_x

[nisse-webrtc, 2016/05/18 16:34:17]

If crop_y is forced to be even (fixed above), then it should be correct with

uv_width = (width + 1) / 2;
uv_plane + uv_width * crop_y + crop_x

Right?

       buffer->MutableData(webrtc::kYPlane), buffer->stride(webrtc::kYPlane),
+      // Swap U and V, since we have NV21, not NV12.
+      buffer->MutableData(webrtc::kVPlane), buffer->stride(webrtc::kVPlane),
       buffer->MutableData(webrtc::kUPlane), buffer->stride(webrtc::kUPlane),
-      buffer->MutableData(webrtc::kVPlane), buffer->stride(webrtc::kVPlane),
-      width, height);
-  AsyncCapturerInvoke("OnIncomingFrame",
-                      &webrtc::AndroidVideoCapturer::OnIncomingFrame,
-                      buffer, rotation, timestamp_ns);
+      crop_width, crop_height, static_cast<libyuv::RotationMode>(
+          capturer_->apply_rotation() ? rotation : 0));
+
+  if (adapted_width != rotated_width || adapted_height != rotated_height) {
+    // TODO(nisse): Use buffer_pool_ here?

[magjed_webrtc, 2016/05/18 15:45:30]

Yes, use a buffer pool here.

[nisse-webrtc, 2016/05/18 16:34:17]

Two buffer pools it is, then. But it would be nice to land
https://codereview.webrtc.org/1988183002/, so that the pool can return an
I420Buffer. Which can reasonably have a scaling method.

Done.

+    buffer = webrtc::I420Buffer::CropAndScale(buffer, 0, 0,
+                                              rotated_width, rotated_height,
+                                              adapted_width, adapted_height);
+  }
+  // TODO(nisse): Use microsecond time instead.
+  capturer_->OnFrame(cricket::WebRtcVideoFrame(
+                         buffer, timestamp_ns,
+                         capturer_->apply_rotation()
+                             ? webrtc::kVideoRotation_0
+                             : static_cast<webrtc::VideoRotation>(rotation)),
+                     width, height);
 }
 
 void AndroidVideoCapturerJni::OnTextureFrame(int width,
                                              int height,
                                              int rotation,
                                              int64_t timestamp_ns,
                                              const NativeHandleImpl& handle) {
-  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
-      surface_texture_helper_->CreateTextureFrame(width, height, handle));
+  RTC_DCHECK(rotation == 0 || rotation == 90 || rotation == 180 ||
+             rotation == 270);
+  rtc::CritScope cs(&capturer_lock_);
 
-  AsyncCapturerInvoke("OnIncomingFrame",
-                      &webrtc::AndroidVideoCapturer::OnIncomingFrame,
-                      buffer, rotation, timestamp_ns);
+  int adapted_width;
+  int adapted_height;
+  int crop_width;
+  int crop_height;
+  int crop_x;
+  int crop_y;
+
+  if (!capturer_->AdaptFrame(width, height, &adapted_width, &adapted_height,
+                             &crop_width, &crop_height, &crop_x, &crop_y)) {
+    return;
+  }
+
+  Matrix matrix = handle.sampling_matrix;
+
+  matrix.Crop(crop_width / static_cast<float>(width),
+              crop_height / static_cast<float>(height),
+              crop_x / static_cast<float>(width),
+              crop_y / static_cast<float>(height));
+
+  if (capturer_->apply_rotation()) {
+    if (rotation == webrtc::kVideoRotation_90 ||
+        rotation == webrtc::kVideoRotation_270) {
+      std::swap(adapted_width, adapted_height);
+    }
+    matrix.Rotate(static_cast<webrtc::VideoRotation>(rotation));
+  }
+
+  // TODO(nisse): Use microsecond time instead.
+  capturer_->OnFrame(
+      cricket::WebRtcVideoFrame(
+          surface_texture_helper_->CreateTextureFrame(
+              adapted_width, adapted_height,
+              NativeHandleImpl(handle.oes_texture_id, matrix)),
+          timestamp_ns, capturer_->apply_rotation()
+                            ? webrtc::kVideoRotation_0
+                            : static_cast<webrtc::VideoRotation>(rotation)),
+      width, height);
 }
 
 void AndroidVideoCapturerJni::OnOutputFormatRequest(int width,
                                                     int height,
                                                     int fps) {
   AsyncCapturerInvoke("OnOutputFormatRequest",
                       &webrtc::AndroidVideoCapturer::OnOutputFormatRequest,
                       width, height, fps);
 }
 
@@ skipping 29 matching lines @@
 
 JOW(void, VideoCapturer_00024NativeObserver_nativeOnOutputFormatRequest)
     (JNIEnv* jni, jclass, jlong j_capturer, jint j_width, jint j_height,
         jint j_fps) {
   LOG(LS_INFO) << "NativeObserver_nativeOnOutputFormatRequest";
   reinterpret_cast<AndroidVideoCapturerJni*>(j_capturer)->OnOutputFormatRequest(
       j_width, j_height, j_fps);
 }
 
 }  // namespace webrtc_jni