Testing of FileVideoCapturer

webrtc/api/android/jni/peerconnection_jni.cc

 /*
  *  Copyright 2013 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 25 matching lines @@
 // impossible to tell which JNI call broke).
 
 #include <jni.h>
 #undef JNIEXPORT
 #define JNIEXPORT __attribute__((visibility("default")))
 
 #include <limits>
 #include <memory>
 #include <utility>
 
+#include "third_party/libyuv/include/libyuv/convert_from.h"
+#include "third_party/libyuv/include/libyuv/scale.h"
 #include "webrtc/api/androidvideotracksource.h"
 #include "webrtc/api/android/jni/androidmediadecoder_jni.h"
 #include "webrtc/api/android/jni/androidmediaencoder_jni.h"
 #include "webrtc/api/android/jni/androidnetworkmonitor_jni.h"
 #include "webrtc/api/android/jni/classreferenceholder.h"
 #include "webrtc/api/android/jni/jni_helpers.h"
 #include "webrtc/api/android/jni/native_handle_impl.h"
 #include "webrtc/api/mediaconstraintsinterface.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/rtpreceiverinterface.h"
@@ skipping 1940 matching lines @@
     memcpy(dst, src, src_stride * height);
   } else {
     for (int i = 0; i < height; i++) {
       memcpy(dst, src, width);
       src += src_stride;
       dst += dst_stride;
     }
   }
 }
 
+JOW(void, FileVideoCapturer_nativeI420ToNV21)(
+    JNIEnv *jni, jclass, jbyteArray j_src_buffer, jint width, jint height,
+    jbyteArray j_dst_buffer) {
+  size_t src_size = jni->GetArrayLength(j_src_buffer);
+  size_t dst_size = jni->GetArrayLength(j_dst_buffer);
+  int src_stride = width;
+  int dst_stride = width;
+  RTC_CHECK(src_size >= src_stride * height * 3 / 2)
+      << "Insufficient source buffer capacity " << src_size;
+  RTC_CHECK(dst_size >= dst_stride * height * 3 / 2)
+      << "Insufficient destination buffer capacity " << dst_size;
+  uint8_t* src =
+      reinterpret_cast<uint8_t*>(jni->GetByteArrayElements(j_src_buffer, 0));
+  uint8_t* dst =
+      reinterpret_cast<uint8_t*>(jni->GetByteArrayElements(j_dst_buffer, 0));
+  uint8_t* src_y = src;
+  size_t src_stride_y = src_stride;
+  uint8_t* src_u = src + src_stride * height;
+  size_t src_stride_u = src_stride / 2;
+  uint8_t* src_v = src + src_stride * height * 5 / 4;
+  size_t src_stride_v = src_stride / 2;
+
+  uint8_t* dst_y = dst;
+  size_t dst_stride_y = dst_stride;
+  size_t dst_stride_uv = dst_stride;
+  uint8_t* dst_uv = dst + dst_stride * height;
+
+  libyuv::I420ToNV21(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                     src_stride_v, dst_y, dst_stride_y, dst_uv, dst_stride_uv,
+                     width, height);
+}
+
+JOW(void, VideoFileRenderer_nativeI420Scale)(
+    JNIEnv *jni, jclass,
+    jobject j_src_buffer_y, jint j_src_stride_y,
+    jobject j_src_buffer_u, jint j_src_stride_u,
+    jobject j_src_buffer_v, jint j_src_stride_v,
+    jint width, jint height,
+    jbyteArray j_dst_buffer, jint dstWidth, jint dstHeight) {
+  size_t src_size_y = jni->GetDirectBufferCapacity(j_src_buffer_y);
+  size_t src_size_u = jni->GetDirectBufferCapacity(j_src_buffer_u);
+  size_t src_size_v = jni->GetDirectBufferCapacity(j_src_buffer_v);
+  size_t dst_size = jni->GetDirectBufferCapacity(j_dst_buffer);
+  int dst_stride = dstWidth;
+  RTC_CHECK(src_size_y >= j_src_stride_y * height)
+      << "Insufficient source y buffer capacity " << src_size_y;
+  RTC_CHECK(src_size_u >= j_src_stride_u * height / 4)
+      << "Insufficient source u buffer capacity " << src_size_u;
+  RTC_CHECK(src_size_v >= j_src_stride_v * height / 4)
+      << "Insufficient source v buffer capacity " << src_size_v;
+  RTC_CHECK(dst_size >= dst_stride * height * 3 / 2)
+      << "Insufficient destination buffer capacity " << dst_size;
+  uint8_t* src_y =
+      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_src_buffer_y));
+  uint8_t* src_u =
+      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_src_buffer_u));
+  uint8_t* src_v =
+      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_src_buffer_v));
+  uint8_t* dst =
+      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_dst_buffer));
+
+  uint8_t* dst_y = dst;
+  size_t dst_stride_y = dst_stride;
+  uint8_t* dst_u = dst + dst_stride * dstHeight;
+  size_t dst_stride_u = dst_stride / 2;
+  uint8_t* dst_v = dst + dst_stride * dstHeight * 5 / 4;
+  size_t dst_stride_v = dst_stride / 2;
+
+  int ret = libyuv::I420Scale(
+      src_y, j_src_stride_y, src_u, j_src_stride_u, src_v, j_src_stride_v,
+      width, height, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v,
+      dst_stride_v, dstWidth, dstHeight, libyuv::kFilterBilinear);
+  if (ret) {
+    LOG(LS_ERROR) << "Error scaling I420 frame: " << ret;
+  }
+}
+
 JOW(jstring, MediaStreamTrack_nativeId)(JNIEnv* jni, jclass, jlong j_p) {
   return JavaStringFromStdString(
       jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->id());
 }
 
 JOW(jstring, MediaStreamTrack_nativeKind)(JNIEnv* jni, jclass, jlong j_p) {
   return JavaStringFromStdString(
       jni, reinterpret_cast<MediaStreamTrackInterface*>(j_p)->kind());
 }
 
@@ skipping 303 matching lines @@
   return JavaStringFromStdString(
       jni,
       reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id());
 }
 
 JOW(void, RtpReceiver_free)(JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
   reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->Release();
 }
 
 }  // namespace webrtc_jni