Build WebRTC with data channel only.

webrtc/sdk/android/src/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 43 matching lines @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event_tracer.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/logsinks.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/rtccertificategenerator.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/media/base/videocapturer.h"
-#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
-#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
 #include "webrtc/modules/utility/include/jvm_android.h"
-#include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/pc/webrtcsdp.h"
-#include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h"
-#include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
 #include "webrtc/sdk/android/src/jni/androidnetworkmonitor_jni.h"
-#include "webrtc/sdk/android/src/jni/androidvideotracksource.h"
+// Adding 'nogncheck' to disable the gn include headers check.
+// We don't want to always depend on audio and video related targets.
+#include "webrtc/sdk/android/src/jni/androidvideotracksource.h"  // nogncheck
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 #include "webrtc/sdk/android/src/jni/jni_helpers.h"
-#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
+#include "webrtc/sdk/android/src/jni/ownedfactoryandthreads.h"
 #include "webrtc/sdk/android/src/jni/rtcstatscollectorcallbackwrapper.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
 // Adding 'nogncheck' to disable the gn include headers check.
 // We don't want to depend on 'system_wrappers:field_trial_default' because
 // clients should be able to provide their own implementation.
 #include "webrtc/system_wrappers/include/field_trial_default.h" // nogncheck
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
 #include "webrtc/system_wrappers/include/trace.h"
-#include "webrtc/voice_engine/include/voe_base.h"
+#include "webrtc/voice_engine/include/voe_base.h"  // nogncheck
 
 using cricket::WebRtcVideoDecoderFactory;
 using cricket::WebRtcVideoEncoderFactory;
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::CreateSessionDescriptionObserver;
@@ skipping 12 matching lines @@
 using webrtc::PeerConnectionInterface;
 using webrtc::PeerConnectionObserver;
 using webrtc::RtpReceiverInterface;
 using webrtc::RtpReceiverObserverInterface;
 using webrtc::RtpSenderInterface;
 using webrtc::SessionDescriptionInterface;
 using webrtc::SetSessionDescriptionObserver;
 using webrtc::StatsObserver;
 using webrtc::StatsReport;
 using webrtc::StatsReports;
-using webrtc::VideoTrackSourceInterface;
 using webrtc::VideoTrackInterface;
-using webrtc::VideoTrackVector;
-using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
+WebRtcVideoEncoderFactory* CreateVideoEncoderFactory();
+
+WebRtcVideoDecoderFactory* CreateVideoDecoderFactory();
+
+jobject GetJavaSurfaceTextureHelper(
+    rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper);
+
 // Field trials initialization string
 static char *field_trials_init_string = NULL;
 
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool video_hw_acceleration_enabled = true;
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 // |state_class_fragment| is something like "MediaSource$State".
 static jobject JavaEnumFromIndex(
@@ skipping 706 matching lines @@
   }
 
   const ScopedGlobalRef<jobject> j_observer_global_;
   const ScopedGlobalRef<jclass> j_observer_class_;
   const ScopedGlobalRef<jclass> j_stats_report_class_;
   const jmethodID j_stats_report_ctor_;
   const ScopedGlobalRef<jclass> j_value_class_;
   const jmethodID j_value_ctor_;
 };
 
-// Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
-// instance.
-class JavaVideoRendererWrapper
-    : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
- public:
-  JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
-      : j_callbacks_(jni, j_callbacks),
-        j_render_frame_id_(GetMethodID(
-            jni, GetObjectClass(jni, j_callbacks), "renderFrame",
-            "(Lorg/webrtc/VideoRenderer$I420Frame;)V")),
-        j_frame_class_(jni,
-                       FindClass(jni, "org/webrtc/VideoRenderer$I420Frame")),
-        j_i420_frame_ctor_id_(GetMethodID(
-            jni, *j_frame_class_, "<init>", "(III[I[Ljava/nio/ByteBuffer;J)V")),
-        j_texture_frame_ctor_id_(GetMethodID(
-            jni, *j_frame_class_, "<init>",
-            "(IIII[FJ)V")),
-        j_byte_buffer_class_(jni, FindClass(jni, "java/nio/ByteBuffer")) {
-    CHECK_EXCEPTION(jni);
-  }
-
-  virtual ~JavaVideoRendererWrapper() {}
-
-  void OnFrame(const webrtc::VideoFrame& video_frame) override {
-    ScopedLocalRefFrame local_ref_frame(jni());
-    jobject j_frame =
-        (video_frame.video_frame_buffer()->native_handle() != nullptr)
-            ? CricketToJavaTextureFrame(&video_frame)
-            : CricketToJavaI420Frame(&video_frame);
-    // |j_callbacks_| is responsible for releasing |j_frame| with
-    // VideoRenderer.renderFrameDone().
-    jni()->CallVoidMethod(*j_callbacks_, j_render_frame_id_, j_frame);
-    CHECK_EXCEPTION(jni());
-  }
-
- private:
-  // Make a shallow copy of |frame| to be used with Java. The callee has
-  // ownership of the frame, and the frame should be released with
-  // VideoRenderer.releaseNativeFrame().
-  static jlong javaShallowCopy(const webrtc::VideoFrame* frame) {
-    return jlongFromPointer(new webrtc::VideoFrame(*frame));
-  }
-
-  // Return a VideoRenderer.I420Frame referring to the data in |frame|.
-  jobject CricketToJavaI420Frame(const webrtc::VideoFrame* frame) {
-    jintArray strides = jni()->NewIntArray(3);
-    jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
-    strides_array[0] = frame->video_frame_buffer()->StrideY();
-    strides_array[1] = frame->video_frame_buffer()->StrideU();
-    strides_array[2] = frame->video_frame_buffer()->StrideV();
-    jni()->ReleaseIntArrayElements(strides, strides_array, 0);
-    jobjectArray planes = jni()->NewObjectArray(3, *j_byte_buffer_class_, NULL);
-    jobject y_buffer = jni()->NewDirectByteBuffer(
-        const_cast<uint8_t*>(frame->video_frame_buffer()->DataY()),
-        frame->video_frame_buffer()->StrideY() *
-            frame->video_frame_buffer()->height());
-    size_t chroma_height = (frame->height() + 1) / 2;
-    jobject u_buffer = jni()->NewDirectByteBuffer(
-        const_cast<uint8_t*>(frame->video_frame_buffer()->DataU()),
-        frame->video_frame_buffer()->StrideU() * chroma_height);
-    jobject v_buffer = jni()->NewDirectByteBuffer(
-        const_cast<uint8_t*>(frame->video_frame_buffer()->DataV()),
-        frame->video_frame_buffer()->StrideV() * chroma_height);
-
-    jni()->SetObjectArrayElement(planes, 0, y_buffer);
-    jni()->SetObjectArrayElement(planes, 1, u_buffer);
-    jni()->SetObjectArrayElement(planes, 2, v_buffer);
-    return jni()->NewObject(
-        *j_frame_class_, j_i420_frame_ctor_id_,
-        frame->width(), frame->height(),
-        static_cast<int>(frame->rotation()),
-        strides, planes, javaShallowCopy(frame));
-  }
-
-  // Return a VideoRenderer.I420Frame referring texture object in |frame|.
-  jobject CricketToJavaTextureFrame(const webrtc::VideoFrame* frame) {
-    NativeHandleImpl* handle = reinterpret_cast<NativeHandleImpl*>(
-        frame->video_frame_buffer()->native_handle());
-    jfloatArray sampling_matrix = handle->sampling_matrix.ToJava(jni());
-
-    return jni()->NewObject(
-        *j_frame_class_, j_texture_frame_ctor_id_,
-        frame->width(), frame->height(),
-        static_cast<int>(frame->rotation()),
-        handle->oes_texture_id, sampling_matrix, javaShallowCopy(frame));
-  }
-
-  JNIEnv* jni() {
-    return AttachCurrentThreadIfNeeded();
-  }
-
-  ScopedGlobalRef<jobject> j_callbacks_;
-  jmethodID j_render_frame_id_;
-  ScopedGlobalRef<jclass> j_frame_class_;
-  jmethodID j_i420_frame_ctor_id_;
-  jmethodID j_texture_frame_ctor_id_;
-  ScopedGlobalRef<jclass> j_byte_buffer_class_;
-};
-
 // Adapter between the C++ RtpReceiverObserverInterface and the Java
 // RtpReceiver.Observer interface. Wraps an instance of the Java interface and
 // dispatches C++ callbacks to Java.
 class RtpReceiverObserver : public RtpReceiverObserverInterface {
  public:
   RtpReceiverObserver(JNIEnv* jni, jobject j_observer)
       : j_observer_global_(jni, j_observer) {}
 
   ~RtpReceiverObserver() override {}
 
@@ skipping 122 matching lines @@
 
 JOW(void, PeerConnection_freeObserver)(JNIEnv*, jclass, jlong j_p) {
   PCOJava* p = reinterpret_cast<PCOJava*>(j_p);
   delete p;
 }
 
 JOW(void, MediaSource_free)(JNIEnv*, jclass, jlong j_p) {
   reinterpret_cast<rtc::RefCountInterface*>(j_p)->Release();
 }
 
-JOW(void, VideoRenderer_freeWrappedVideoRenderer)(JNIEnv*, jclass, jlong j_p) {
-  delete reinterpret_cast<JavaVideoRendererWrapper*>(j_p);
-}
-
-JOW(void, VideoRenderer_releaseNativeFrame)(
-    JNIEnv* jni, jclass, jlong j_frame_ptr) {
-  delete reinterpret_cast<const webrtc::VideoFrame*>(j_frame_ptr);
-}
-
 JOW(void, MediaStreamTrack_free)(JNIEnv*, jclass, jlong j_p) {
   reinterpret_cast<MediaStreamTrackInterface*>(j_p)->Release();
 }
 
 JOW(jboolean, MediaStream_nativeAddAudioTrack)(
     JNIEnv* jni, jclass, jlong pointer, jlong j_audio_track_pointer) {
   return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
       reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
 }
 
@@ skipping 88 matching lines @@
   rtc::tracing::ShutdownInternalTracer();
 }
 
 JOW(void, AudioTrack_nativeSetVolume)
 (JNIEnv*, jclass, jlong j_p, jdouble volume) {
   rtc::scoped_refptr<AudioSourceInterface> source(
       reinterpret_cast<AudioTrackInterface*>(j_p)->GetSource());
   source->SetVolume(volume);
 }
 
-// Helper struct for working around the fact that CreatePeerConnectionFactory()
-// comes in two flavors: either entirely automagical (constructing its own
-// threads and deleting them on teardown, but no external codec factory support)
-// or entirely manual (requires caller to delete threads after factory
-// teardown).  This struct takes ownership of its ctor's arguments to present a
-// single thing for Java to hold and eventually free.
-class OwnedFactoryAndThreads {
- public:
-  OwnedFactoryAndThreads(std::unique_ptr<Thread> network_thread,
-                         std::unique_ptr<Thread> worker_thread,
-                         std::unique_ptr<Thread> signaling_thread,
-                         WebRtcVideoEncoderFactory* encoder_factory,
-                         WebRtcVideoDecoderFactory* decoder_factory,
-                         rtc::NetworkMonitorFactory* network_monitor_factory,
-                         PeerConnectionFactoryInterface* factory)
-      : network_thread_(std::move(network_thread)),
-        worker_thread_(std::move(worker_thread)),
-        signaling_thread_(std::move(signaling_thread)),
-        encoder_factory_(encoder_factory),
-        decoder_factory_(decoder_factory),
-        network_monitor_factory_(network_monitor_factory),
-        factory_(factory) {}
-
-  ~OwnedFactoryAndThreads() {
-    CHECK_RELEASE(factory_);
-    if (network_monitor_factory_ != nullptr) {
-      rtc::NetworkMonitorFactory::ReleaseFactory(network_monitor_factory_);
-    }
-  }
-
-  PeerConnectionFactoryInterface* factory() { return factory_; }
-  Thread* signaling_thread() { return signaling_thread_.get(); }
-  Thread* worker_thread() { return worker_thread_.get(); }
-  WebRtcVideoEncoderFactory* encoder_factory() { return encoder_factory_; }
-  WebRtcVideoDecoderFactory* decoder_factory() { return decoder_factory_; }
-  rtc::NetworkMonitorFactory* network_monitor_factory() {
-    return network_monitor_factory_;
-  }
-  void clear_network_monitor_factory() { network_monitor_factory_ = nullptr; }
-  void InvokeJavaCallbacksOnFactoryThreads();
-
- private:
-  void JavaCallbackOnFactoryThreads();
-
-  const std::unique_ptr<Thread> network_thread_;
-  const std::unique_ptr<Thread> worker_thread_;
-  const std::unique_ptr<Thread> signaling_thread_;
-  WebRtcVideoEncoderFactory* encoder_factory_;
-  WebRtcVideoDecoderFactory* decoder_factory_;
-  rtc::NetworkMonitorFactory* network_monitor_factory_;
-  PeerConnectionFactoryInterface* factory_;  // Const after ctor except dtor.
-};
-
-void OwnedFactoryAndThreads::JavaCallbackOnFactoryThreads() {
-  JNIEnv* jni = AttachCurrentThreadIfNeeded();
-  ScopedLocalRefFrame local_ref_frame(jni);
-  jclass j_factory_class = FindClass(jni, "org/webrtc/PeerConnectionFactory");
-  jmethodID m = nullptr;
-  if (network_thread_->IsCurrent()) {
-    LOG(LS_INFO) << "Network thread JavaCallback";
-    m = GetStaticMethodID(jni, j_factory_class, "onNetworkThreadReady", "()V");
-  }
-  if (worker_thread_->IsCurrent()) {
-    LOG(LS_INFO) << "Worker thread JavaCallback";
-    m = GetStaticMethodID(jni, j_factory_class, "onWorkerThreadReady", "()V");
-  }
-  if (signaling_thread_->IsCurrent()) {
-    LOG(LS_INFO) << "Signaling thread JavaCallback";
-    m = GetStaticMethodID(
-        jni, j_factory_class, "onSignalingThreadReady", "()V");
-  }
-  if (m != nullptr) {
-    jni->CallStaticVoidMethod(j_factory_class, m);
-    CHECK_EXCEPTION(jni) << "error during JavaCallback::CallStaticVoidMethod";
-  }
-}
-
-void OwnedFactoryAndThreads::InvokeJavaCallbacksOnFactoryThreads() {
-  LOG(LS_INFO) << "InvokeJavaCallbacksOnFactoryThreads.";
-  network_thread_->Invoke<void>(RTC_FROM_HERE,
-                                [this] { JavaCallbackOnFactoryThreads(); });
-  worker_thread_->Invoke<void>(RTC_FROM_HERE,
-                               [this] { JavaCallbackOnFactoryThreads(); });
-  signaling_thread_->Invoke<void>(RTC_FROM_HERE,
-                                  [this] { JavaCallbackOnFactoryThreads(); });
-}
-
 PeerConnectionFactoryInterface::Options ParseOptionsFromJava(JNIEnv* jni,
                                                              jobject options) {
   jclass options_class = jni->GetObjectClass(options);
   jfieldID network_ignore_mask_field =
       jni->GetFieldID(options_class, "networkIgnoreMask", "I");
   int network_ignore_mask =
       jni->GetIntField(options, network_ignore_mask_field);
 
   jfieldID disable_encryption_field =
       jni->GetFieldID(options_class, "disableEncryption", "Z");
@@ skipping 42 matching lines @@
   WebRtcVideoDecoderFactory* decoder_factory = nullptr;
   rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;
 
   PeerConnectionFactoryInterface::Options options;
   bool has_options = joptions != NULL;
   if (has_options) {
     options = ParseOptionsFromJava(jni, joptions);
   }
 
   if (video_hw_acceleration_enabled) {
-    encoder_factory = new MediaCodecVideoEncoderFactory();
-    decoder_factory = new MediaCodecVideoDecoderFactory();
+    encoder_factory = CreateVideoEncoderFactory();
+    decoder_factory = CreateVideoDecoderFactory();
   }
   // Do not create network_monitor_factory only if the options are
   // provided and disable_network_monitor therein is set to true.
   if (!(has_options && options.disable_network_monitor)) {
     network_monitor_factory = new AndroidNetworkMonitorFactory();
     rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);
   }
 
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(
@@ skipping 17 matching lines @@
 JOW(void, PeerConnectionFactory_nativeFreeFactory)(JNIEnv*, jclass, jlong j_p) {
   delete reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
   if (field_trials_init_string) {
     webrtc::field_trial::InitFieldTrialsFromString(NULL);
     delete field_trials_init_string;
     field_trials_init_string = NULL;
   }
   webrtc::Trace::ReturnTrace();
 }
 
-static PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
-  return reinterpret_cast<OwnedFactoryAndThreads*>(j_p)->factory();
-}
-
 JOW(void, PeerConnectionFactory_nativeThreadsCallbacks)(
     JNIEnv*, jclass, jlong j_p) {
   OwnedFactoryAndThreads *factory =
       reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
   factory->InvokeJavaCallbacksOnFactoryThreads();
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateLocalMediaStream)(
     JNIEnv* jni, jclass, jlong native_factory, jstring label) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<MediaStreamInterface> stream(
       factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
   return (jlong)stream.release();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource)
-(JNIEnv* jni,
- jclass,
- jlong native_factory,
- jobject j_surface_texture_helper,
- jboolean is_screencast) {
-  OwnedFactoryAndThreads* factory =
-      reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
-
-  rtc::scoped_refptr<webrtc::AndroidVideoTrackSource> source(
-      new rtc::RefCountedObject<webrtc::AndroidVideoTrackSource>(
-          factory->signaling_thread(), jni, j_surface_texture_helper,
-          is_screencast));
-  rtc::scoped_refptr<webrtc::VideoTrackSourceProxy> proxy_source =
-      webrtc::VideoTrackSourceProxy::Create(factory->signaling_thread(),
-                                            factory->worker_thread(), source);
-
-  return (jlong)proxy_source.release();
-}
-
-JOW(jlong, PeerConnectionFactory_nativeCreateVideoTrack)(
-    JNIEnv* jni, jclass, jlong native_factory, jstring id,
-    jlong native_source) {
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
-      factoryFromJava(native_factory));
-  rtc::scoped_refptr<VideoTrackInterface> track(factory->CreateVideoTrack(
-      JavaToStdString(jni, id),
-      reinterpret_cast<VideoTrackSourceInterface*>(native_source)));
-  return (jlong)track.release();
-}
-
 JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)(
     JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) {
   std::unique_ptr<ConstraintsWrapper> constraints(
       new ConstraintsWrapper(jni, j_constraints));
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   cricket::AudioOptions options;
   CopyConstraintsIntoAudioOptions(constraints.get(), &options);
   rtc::scoped_refptr<AudioSourceInterface> source(
       factory->CreateAudioSource(options));
@@ skipping 38 matching lines @@
     OwnedFactoryAndThreads* owner =
         reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
     if (owner->network_monitor_factory()) {
       rtc::NetworkMonitorFactory::ReleaseFactory(
           owner->network_monitor_factory());
       owner->clear_network_monitor_factory();
     }
   }
 }
 
-JOW(void, PeerConnectionFactory_nativeSetVideoHwAccelerationOptions)(
-    JNIEnv* jni, jclass, jlong native_factory, jobject local_egl_context,
-    jobject remote_egl_context) {
-  OwnedFactoryAndThreads* owned_factory =
-      reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
-
-  jclass j_eglbase14_context_class =
-      FindClass(jni, "org/webrtc/EglBase14$Context");
-
-  MediaCodecVideoEncoderFactory* encoder_factory =
-      static_cast<MediaCodecVideoEncoderFactory*>
-          (owned_factory->encoder_factory());
-  if (encoder_factory &&
-      jni->IsInstanceOf(local_egl_context, j_eglbase14_context_class)) {
-    LOG(LS_INFO) << "Set EGL context for HW encoding.";
-    encoder_factory->SetEGLContext(jni, local_egl_context);
-  }
-
-  MediaCodecVideoDecoderFactory* decoder_factory =
-      static_cast<MediaCodecVideoDecoderFactory*>
-          (owned_factory->decoder_factory());
-  if (decoder_factory) {
-    LOG(LS_INFO) << "Set EGL context for HW decoding.";
-    decoder_factory->SetEGLContext(jni, remote_egl_context);
-  }
-}
-
 static PeerConnectionInterface::IceTransportsType
 JavaIceTransportsTypeToNativeType(JNIEnv* jni, jobject j_ice_transports_type) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$IceTransportsType",
       j_ice_transports_type);
 
   if (enum_name == "ALL")
     return PeerConnectionInterface::kAll;
 
   if (enum_name == "RELAY")
@@ skipping 611 matching lines @@
   ExtractNativePC(jni, j_pc)->Close();
   return;
 }
 
 JOW(jobject, MediaSource_nativeState)(JNIEnv* jni, jclass, jlong j_p) {
   rtc::scoped_refptr<MediaSourceInterface> p(
       reinterpret_cast<MediaSourceInterface*>(j_p));
   return JavaEnumFromIndex(jni, "MediaSource$State", p->state());
 }
 
-JOW(jlong, VideoRenderer_nativeWrapVideoRenderer)(
-    JNIEnv* jni, jclass, jobject j_callbacks) {
-  std::unique_ptr<JavaVideoRendererWrapper> renderer(
-      new JavaVideoRendererWrapper(jni, j_callbacks));
-  return (jlong)renderer.release();
-}
-
-JOW(void, VideoRenderer_nativeCopyPlane)(
-    JNIEnv *jni, jclass, jobject j_src_buffer, jint width, jint height,
-    jint src_stride, jobject j_dst_buffer, jint dst_stride) {
-  size_t src_size = jni->GetDirectBufferCapacity(j_src_buffer);
-  size_t dst_size = jni->GetDirectBufferCapacity(j_dst_buffer);
-  RTC_CHECK(src_stride >= width) << "Wrong source stride " << src_stride;
-  RTC_CHECK(dst_stride >= width) << "Wrong destination stride " << dst_stride;
-  RTC_CHECK(src_size >= src_stride * height)
-      << "Insufficient source buffer capacity " << src_size;
-  RTC_CHECK(dst_size >= dst_stride * height)
-      << "Insufficient destination buffer capacity " << dst_size;
-  uint8_t *src =
-      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_src_buffer));
-  uint8_t *dst =
-      reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_dst_buffer));
-  if (src_stride == dst_stride) {
-    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_GE(src_size, src_stride * height * 3 / 2);
   RTC_CHECK_GE(dst_size, dst_stride * height * 3 / 2);
 
@@ skipping 511 matching lines @@
   return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
       ->inter_tone_gap();
 }
 
 JOW(void, DtmfSender_free)
 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) {
   reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)->Release();
 }
 
 }  // namespace webrtc_jni