Better handling of error condition in MediaCodecVideoEncoder.

webrtc/sdk/android/src/jni/androidmediaencoder_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 438 matching lines @@
   if (!encoder_->inited_) {
     encoder_->encode_task_ = std::unique_ptr<rtc::QueuedTask>(this);
     return false;
   }
 
   // It would be nice to recover from a failure here if one happened, but it's
   // unclear how to signal such a failure to the app, so instead we stay silent
   // about it and let the next app-called API method reveal the borkedness.
   encoder_->DeliverPendingOutputs(jni);
 
+  if (!encoder_) {
+    // Encoder can be destroyed in DeliverPendingOutputs.
+    return true;
+  }
+
   // Call log statistics here so it's called even if no frames are being
   // delivered.
   encoder_->LogStatistics(false);
 
   // If there aren't more frames to deliver, we can start polling at lower rate.
   if (encoder_->input_frame_infos_.empty()) {
     rtc::TaskQueue::Current()->PostDelayedTask(
         std::unique_ptr<rtc::QueuedTask>(this), kMediaCodecPollNoFramesMs);
   } else {
     rtc::TaskQueue::Current()->PostDelayedTask(
@@ skipping 69 matching lines @@
   output_render_time_ms_ = 0;
   input_frame_infos_.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;
   last_frame_received_ms_ = -1;
   frames_received_since_last_key_ = kMinKeyFrameInterval;
-  weak_factory_.reset(new rtc::WeakPtrFactory<MediaCodecVideoEncoder>(this));
-  encode_task_.reset(new EncodeTask(weak_factory_->GetWeakPtr()));
 
   // We enforce no extra stride/padding in the format creation step.
   jobject j_video_codec_enum = JavaEnumFromIndexAndClassName(
       jni, "MediaCodecVideoEncoder$VideoCodecType", codec_type);
   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.";
@@ skipping 53 matching lines @@
       RTC_CHECK(yuv_buffer_capacity >= yuv_size_) << "Insufficient capacity";
     }
   }
 
   {
 #if RTC_DCHECK_IS_ON
     rtc::CritScope lock(&inited_crit_);
 #endif
     inited_ = true;
   }
+  weak_factory_.reset(new rtc::WeakPtrFactory<MediaCodecVideoEncoder>(this));
+  encode_task_.reset(new EncodeTask(weak_factory_->GetWeakPtr()));
+
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::Encode(
     const webrtc::VideoFrame& frame,
     const webrtc::CodecSpecificInfo* /* codec_specific_info */,
     const std::vector<webrtc::FrameType>* frame_types) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (sw_fallback_required_)
     return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
@@ skipping 244 matching lines @@
 
 int32_t MediaCodecVideoEncoder::Release() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ALOGD << "EncoderRelease: Frames received: " << frames_received_
         << ". Encoded: " << frames_encoded_
         << ". Dropped: " << frames_dropped_media_encoder_;
+  encode_task_.reset(nullptr);
+  weak_factory_.reset(nullptr);
   ScopedLocalRefFrame local_ref_frame(jni);
   for (size_t i = 0; i < input_buffers_.size(); ++i)
     jni->DeleteGlobalRef(input_buffers_[i]);
   input_buffers_.clear();
   jni->CallVoidMethod(*j_media_codec_video_encoder_, j_release_method_);
   if (CheckException(jni)) {
     ALOGE << "Exception in release.";
     ProcessHWError(false /* reset_if_fallback_unavailable */);
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   {
 #if RTC_DCHECK_IS_ON
     rtc::CritScope lock(&inited_crit_);
 #endif
     inited_ = false;
   }
   use_surface_ = false;
-  encode_task_.reset(nullptr);
-  weak_factory_.reset(nullptr);
   ALOGD << "EncoderRelease done.";
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::SetRateAllocation(
     const webrtc::BitrateAllocation& rate_allocation,
     uint32_t frame_rate) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   const uint32_t new_bit_rate = rate_allocation.get_sum_kbps();
   if (sw_fallback_required_)
@@ skipping 389 matching lines @@
   }
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni