Change PeerConnectionFactory.setVideoHwAccelerationOptions to create shared Egl context for harware…

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

 /*
  * libjingle
  * Copyright 2015 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 109 matching lines @@
                                int64_t /* rtt */) override;
   int32_t SetRates(uint32_t new_bit_rate, uint32_t frame_rate) override;
 
   // rtc::MessageHandler implementation.
   void OnMessage(rtc::Message* msg) override;
 
   void OnDroppedFrame() override;
 
   int GetTargetFramerate() override;
 
-  bool SupportsNativeHandle() const override { return true; }
+  bool SupportsNativeHandle() const override { return egl_context_ != nullptr; }
   const char* ImplementationName() const override;
 
  private:
   // CHECK-fail if not running on |codec_thread_|.
   void CheckOnCodecThread();
 
  private:
   // ResetCodecOnCodecThread() calls ReleaseOnCodecThread() and
   // InitEncodeOnCodecThread() in an attempt to restore the codec to an
   // operable state.  Necessary after all manner of OMX-layer errors.
@@ skipping 372 matching lines @@
   render_times_ms_.clear();
   frame_rtc_times_ms_.clear();
   drop_next_input_frame_ = false;
   use_surface_ = use_surface;
   picture_id_ = static_cast<uint16_t>(rand()) & 0x7FFF;
   gof_.SetGofInfoVP9(webrtc::TemporalStructureMode::kTemporalStructureMode1);
   tl0_pic_idx_ = static_cast<uint8_t>(rand());
   gof_idx_ = 0;
 
   // We enforce no extra stride/padding in the format creation step.
-  jobject j_video_codec_enum = JavaEnumFromIndex(
+  jobject j_video_codec_enum = JavaEnumFromIndexAndClassName(
       jni, "MediaCodecVideoEncoder$VideoCodecType", codecType_);
   const bool encode_status = jni->CallBooleanMethod(
       *j_media_codec_video_encoder_, j_init_encode_method_,
       j_video_codec_enum, width, height, kbps, fps,
       (use_surface ? egl_context_ : nullptr));
   if (!encode_status) {
     ALOGE << "Failed to configure encoder.";
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   CHECK_EXCEPTION(jni);
@@ skipping 573 matching lines @@
 }
 
 int MediaCodecVideoEncoder::GetTargetFramerate() {
   return scale_ ? quality_scaler_.GetTargetFramerate() : -1;
 }
 
 const char* MediaCodecVideoEncoder::ImplementationName() const {
   return "MediaCodec";
 }
 
-MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
-    : egl_context_(nullptr) {
+MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory() {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_encoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoEncoder");
   supported_codecs_.clear();
 
   bool is_vp8_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isVp8HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_vp8_hw_supported) {
@@ skipping 16 matching lines @@
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isH264HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_h264_hw_supported) {
     ALOGD << "H.264 HW Encoder supported.";
     supported_codecs_.push_back(VideoCodec(kVideoCodecH264, "H264",
         MAX_VIDEO_WIDTH, MAX_VIDEO_HEIGHT, MAX_VIDEO_FPS));
   }
 }
 
-MediaCodecVideoEncoderFactory::~MediaCodecVideoEncoderFactory() {}
+MediaCodecVideoEncoderFactory::~MediaCodecVideoEncoderFactory() {
+  ALOGD << "MediaCodecVideoEncoderFactory dtor";
+}
 
 void MediaCodecVideoEncoderFactory::SetEGLContext(
     JNIEnv* jni, jobject render_egl_context) {
   ALOGD << "MediaCodecVideoEncoderFactory::SetEGLContext";
-  if (egl_context_) {
-    jni->DeleteGlobalRef(egl_context_);
-    egl_context_ = NULL;
-  }
-  if (!IsNull(jni, render_egl_context)) {
-    egl_context_ = jni->NewGlobalRef(render_egl_context);
-    if (CheckException(jni)) {
-      ALOGE << "error calling NewGlobalRef for EGL Context.";
-      egl_context_ = NULL;
-    } else {
-      jclass j_egl_context_class =
-          FindClass(jni, "org/webrtc/EglBase14$Context");
-      if (!jni->IsInstanceOf(egl_context_, j_egl_context_class)) {
-        ALOGE << "Wrong EGL Context.";
-        jni->DeleteGlobalRef(egl_context_);
-        egl_context_ = NULL;
-      }
-    }
-  }
-  if (egl_context_ == NULL) {
-    ALOGW << "NULL VideoDecoder EGL context - HW surface encoding is disabled.";
+  if (!egl_base_.CreateEglBase(jni, render_egl_context)) {
+    ALOGW << "Invalid EGL context - HW surface encoding is disabled.";
   }
 }
 
 webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
     VideoCodecType type) {
   if (supported_codecs_.empty()) {
     ALOGW << "No HW video encoder for type " << (int)type;
-    return NULL;
+    return nullptr;
   }
   for (std::vector<VideoCodec>::const_iterator it = supported_codecs_.begin();
          it != supported_codecs_.end(); ++it) {
     if (it->type == type) {
       ALOGD << "Create HW video encoder for type " << (int)type <<
           " (" << it->name << ").";
       return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), type,
-          egl_context_);
+          egl_base_.egl_base_context());
     }
   }
   ALOGW << "Can not find HW video encoder for type " << (int)type;
-  return NULL;
+  return nullptr;
 }
 
 const std::vector<MediaCodecVideoEncoderFactory::VideoCodec>&
 MediaCodecVideoEncoderFactory::codecs() const {
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni