Move shared EGL context initialization to a separate function.

talk/app/webrtc/java/jni/peerconnection_jni.cc

 /*
  * libjingle
  * Copyright 2013 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 71 matching lines @@
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 #include "talk/app/webrtc/androidvideocapturer.h"
 #include "talk/app/webrtc/java/jni/androidmediadecoder_jni.h"
 #include "talk/app/webrtc/java/jni/androidmediaencoder_jni.h"
 #include "talk/app/webrtc/java/jni/androidvideocapturer_jni.h"
 #include "webrtc/modules/video_render/video_render_internal.h"
 #include "webrtc/system_wrappers/interface/logcat_trace_context.h"
 using webrtc::LogcatTraceContext;
 #endif
 
+using cricket::WebRtcVideoDecoderFactory;
+using cricket::WebRtcVideoEncoderFactory;
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 using rtc::scoped_ptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInit;
@@ skipping 19 matching lines @@
 using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
 // Field trials initialization string
 static char *field_trials_init_string = NULL;
 
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
-static bool vp8_hw_acceleration_enabled = true;
+static bool video_hw_acceleration_enabled = true;
 #endif
 
 extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
   jint ret = InitGlobalJniVariables(jvm);
   if (ret < 0)
     return -1;
 
   CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
   LoadGlobalClassReferenceHolder();
 
@@ skipping 849 matching lines @@
 
 JOW(jlong, PeerConnectionFactory_nativeCreateObserver)(
     JNIEnv * jni, jclass, jobject j_observer) {
   return (jlong)new PCOJava(jni, j_observer);
 }
 
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 JOW(jboolean, PeerConnectionFactory_initializeAndroidGlobals)(
     JNIEnv* jni, jclass, jobject context,
     jboolean initialize_audio, jboolean initialize_video,
-    jboolean vp8_hw_acceleration, jobject render_egl_context) {
+    jboolean video_hw_acceleration) {
   bool failure = false;
-  vp8_hw_acceleration_enabled = vp8_hw_acceleration;
+  video_hw_acceleration_enabled = video_hw_acceleration;
   if (!factory_static_initialized) {
     if (initialize_video) {
       failure |= webrtc::SetRenderAndroidVM(GetJVM());
       failure |= AndroidVideoCapturerJni::SetAndroidObjects(jni, context);
     }
     if (initialize_audio)
       failure |= webrtc::VoiceEngine::SetAndroidObjects(GetJVM(), context);
     factory_static_initialized = true;
   }
-  if (initialize_video) {
-    failure |= MediaCodecVideoDecoderFactory::SetAndroidObjects(jni,
-        render_egl_context);
-  }
   return !failure;
 }
 #endif  // defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 
 JOW(void, PeerConnectionFactory_initializeFieldTrials)(
     JNIEnv* jni, jclass, jstring j_trials_init_string) {
   field_trials_init_string = NULL;
   if (j_trials_init_string != NULL) {
     const char* init_string =
         jni->GetStringUTFChars(j_trials_init_string, NULL);
     int init_string_length = jni->GetStringUTFLength(j_trials_init_string);
     field_trials_init_string = new char[init_string_length + 1];
     rtc::strcpyn(field_trials_init_string, init_string_length + 1, init_string);
     jni->ReleaseStringUTFChars(j_trials_init_string, init_string);
     LOG(LS_INFO) << "initializeFieldTrials: " << field_trials_init_string;
   }
   webrtc::field_trial::InitFieldTrialsFromString(field_trials_init_string);
 }
 
 // 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(Thread* worker_thread,
                          Thread* signaling_thread,
+                         WebRtcVideoEncoderFactory* encoder_factory,
+                         WebRtcVideoDecoderFactory* decoder_factory,
                          PeerConnectionFactoryInterface* factory)
       : worker_thread_(worker_thread),
         signaling_thread_(signaling_thread),
+        encoder_factory_(encoder_factory),
+        decoder_factory_(decoder_factory),
         factory_(factory) {}
 
   ~OwnedFactoryAndThreads() { CHECK_RELEASE(factory_); }
 
   PeerConnectionFactoryInterface* factory() { return factory_; }
+  WebRtcVideoEncoderFactory* encoder_factory() { return encoder_factory_; }
+  WebRtcVideoDecoderFactory* decoder_factory() { return decoder_factory_; }
 
  private:
   const scoped_ptr<Thread> worker_thread_;
   const scoped_ptr<Thread> signaling_thread_;
+  WebRtcVideoEncoderFactory* encoder_factory_;
+  WebRtcVideoDecoderFactory* decoder_factory_;
   PeerConnectionFactoryInterface* factory_;  // Const after ctor except dtor.
 };
 
 JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnectionFactory)(
     JNIEnv* jni, jclass) {
   // talk/ assumes pretty widely that the current Thread is ThreadManager'd, but
   // ThreadManager only WrapCurrentThread()s the thread where it is first
   // created.  Since the semantics around when auto-wrapping happens in
   // webrtc/base/ are convoluted, we simply wrap here to avoid having to think
   // about ramifications of auto-wrapping there.
   rtc::ThreadManager::Instance()->WrapCurrentThread();
   webrtc::Trace::CreateTrace();
   Thread* worker_thread = new Thread();
   worker_thread->SetName("worker_thread", NULL);
   Thread* signaling_thread = new Thread();
   signaling_thread->SetName("signaling_thread", NULL);
   CHECK(worker_thread->Start() && signaling_thread->Start())
       << "Failed to start threads";
-  scoped_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
-  scoped_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
+  WebRtcVideoEncoderFactory* encoder_factory = nullptr;
+  WebRtcVideoDecoderFactory* decoder_factory = nullptr;
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
-  if (vp8_hw_acceleration_enabled) {
-    encoder_factory.reset(new MediaCodecVideoEncoderFactory());
-    decoder_factory.reset(new MediaCodecVideoDecoderFactory());
+  if (video_hw_acceleration_enabled) {
+    encoder_factory = new MediaCodecVideoEncoderFactory();
+    decoder_factory = new MediaCodecVideoDecoderFactory();
   }
 #endif
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(worker_thread,
                                           signaling_thread,
                                           NULL,
-                                          encoder_factory.release(),
-                                          decoder_factory.release()));
+                                          encoder_factory,
+                                          decoder_factory));
   OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads(
-      worker_thread, signaling_thread, factory.release());
+      worker_thread, signaling_thread,
+      encoder_factory, decoder_factory,
+      factory.release());
   return jlongFromPointer(owned_factory);
 }
 
 JOW(void, PeerConnectionFactory_freeFactory)(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;
   }
@@ skipping 78 matching lines @@
 
   PeerConnectionFactoryInterface::Options options_to_set;
 
   // This doesn't necessarily match the c++ version of this struct; feel free
   // to add more parameters as necessary.
   options_to_set.network_ignore_mask = network_ignore_mask;
   options_to_set.disable_encryption = disable_encryption;
   factory->SetOptions(options_to_set);
 }
 
+JOW(void, PeerConnectionFactory_nativeSetVideoHwAccelerationOptions)(
+    JNIEnv* jni, jclass, jlong native_factory, jobject render_egl_context) {
+#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
+  OwnedFactoryAndThreads* owned_factory =
+      reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
+  MediaCodecVideoDecoderFactory* decoder_factory =
+      static_cast<MediaCodecVideoDecoderFactory*>
+          (owned_factory->decoder_factory());
+  if (decoder_factory) {
+    LOG(LS_INFO) << "Set EGL context for HW acceleration.";
+    decoder_factory->SetEGLContext(jni, render_egl_context);
+  }
+#endif
+}
+
+
 static std::string
 GetJavaEnumName(JNIEnv* jni, const std::string& className, jobject j_enum) {
   jclass enumClass = FindClass(jni, className.c_str());
   jmethodID nameMethod =
       GetMethodID(jni, enumClass, "name", "()Ljava/lang/String;");
   jstring name =
       reinterpret_cast<jstring>(jni->CallObjectMethod(j_enum, nameMethod));
   CHECK_EXCEPTION(jni) << "error during CallObjectMethod for "
                        << className << ".name";
   return JavaToStdString(jni, name);
@@ skipping 502 matching lines @@
 }
 
 JOW(void, VideoTrack_nativeRemoveRenderer)(
     JNIEnv* jni, jclass,
     jlong j_video_track_pointer, jlong j_renderer_pointer) {
   reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)->RemoveRenderer(
       reinterpret_cast<VideoRendererInterface*>(j_renderer_pointer));
 }
 
 }  // namespace webrtc_jni