Make MediaCodecEncoder fallback to a software encoder on failure.

webrtc/api/android/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 111 matching lines @@
 
   void OnDroppedFrame() override;
 
   bool SupportsNativeHandle() const override { return egl_context_ != nullptr; }
   const char* ImplementationName() const override;
 
  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.
+  // Returns true if the codec was reset successfully.
   bool ResetCodecOnCodecThread();
 
+  // Fallback to a software encoder if one is supported else try to reset the
+  // encoder. Called with |reset_if_fallback_unavailable| equal to false from
+  // init/release encoder so that we don't go into infinite recursion.
+  // Returns true if the codec was reset successfully.
+  bool ProcessHWErrorOnCodecThread(bool reset_if_fallback_unavailable);
+
+  // Calls ProcessHWErrorOnCodecThread(true). Returns
+  // WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE if sw_fallback_required_ was set or
+  // WEBRTC_VIDEO_CODEC_ERROR otherwise.
+  int32_t ProcessHWErrorOnEncodeOnCodecThread();
+
   // Implementation of webrtc::VideoEncoder methods above, all running on the
   // codec thread exclusively.
   //
   // If width==0 then this is assumed to be a re-initialization and the
   // previously-current values are reused instead of the passed parameters
   // (makes it easier to reason about thread-safety).
   int32_t InitEncodeOnCodecThread(int width, int height, int kbps, int fps,
       bool use_surface);
   // Reconfigure to match |frame| in width, height. Also reconfigures the
   // encoder if |frame| is a texture/byte buffer and the encoder is initialized
@@ skipping 131 matching lines @@
   // EGL context - owned by factory, should not be allocated/destroyed
   // by MediaCodecVideoEncoder.
   jobject egl_context_;
 
   // Temporary fix for VP8.
   // Sends a key frame if frames are largely spaced apart (possibly
   // corresponding to a large image change).
   int64_t last_frame_received_ms_;
   int frames_received_since_last_key_;
   webrtc::VideoCodecMode codec_mode_;
+
+  bool sw_fallback_required_;
 };
 
 MediaCodecVideoEncoder::~MediaCodecVideoEncoder() {
   // Call Release() to ensure no more callbacks to us after we are deleted.
   Release();
 }
 
-MediaCodecVideoEncoder::MediaCodecVideoEncoder(
-    JNIEnv* jni, VideoCodecType codecType, jobject egl_context) :
-    codecType_(codecType),
-    callback_(NULL),
-    codec_thread_(new Thread()),
-    j_media_codec_video_encoder_class_(
-        jni,
-        FindClass(jni, "org/webrtc/MediaCodecVideoEncoder")),
-    j_media_codec_video_encoder_(
-        jni,
-        jni->NewObject(*j_media_codec_video_encoder_class_,
-                       GetMethodID(jni,
-                                   *j_media_codec_video_encoder_class_,
-                                   "<init>",
-                                   "()V"))),
-    inited_(false),
-    use_surface_(false),
-    picture_id_(0),
-    egl_context_(egl_context) {
+MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni,
+                                               VideoCodecType codecType,
+                                               jobject egl_context)
+    : codecType_(codecType),
+      callback_(NULL),
+      codec_thread_(new Thread()),
+      j_media_codec_video_encoder_class_(
+          jni,
+          FindClass(jni, "org/webrtc/MediaCodecVideoEncoder")),
+      j_media_codec_video_encoder_(
+          jni,
+          jni->NewObject(*j_media_codec_video_encoder_class_,
+                         GetMethodID(jni,
+                                     *j_media_codec_video_encoder_class_,
+                                     "<init>",
+                                     "()V"))),
+      inited_(false),
+      use_surface_(false),
+      picture_id_(0),
+      egl_context_(egl_context),
+      sw_fallback_required_(false) {
   ScopedLocalRefFrame local_ref_frame(jni);
   // It would be nice to avoid spinning up a new thread per MediaCodec, and
   // instead re-use e.g. the PeerConnectionFactory's |worker_thread_|, but bug
   // 2732 means that deadlocks abound.  This class synchronously trampolines
   // to |codec_thread_|, so if anything else can be coming to _us_ from
   // |codec_thread_|, or from any thread holding the |_sendCritSect| described
   // in the bug, we have a problem.  For now work around that with a dedicated
   // thread.
   codec_thread_->SetName("MediaCodecVideoEncoder", NULL);
   RTC_CHECK(codec_thread_->Start()) << "Failed to start MediaCodecVideoEncoder";
@@ skipping 33 matching lines @@
   j_color_format_field_ =
       GetFieldID(jni, *j_media_codec_video_encoder_class_, "colorFormat", "I");
   j_info_index_field_ =
       GetFieldID(jni, j_output_buffer_info_class, "index", "I");
   j_info_buffer_field_ = GetFieldID(
       jni, j_output_buffer_info_class, "buffer", "Ljava/nio/ByteBuffer;");
   j_info_is_key_frame_field_ =
       GetFieldID(jni, j_output_buffer_info_class, "isKeyFrame", "Z");
   j_info_presentation_timestamp_us_field_ = GetFieldID(
       jni, j_output_buffer_info_class, "presentationTimestampUs", "J");
-  CHECK_EXCEPTION(jni) << "MediaCodecVideoEncoder ctor failed";
+  if (CheckException(jni)) {
+    ALOGW << "MediaCodecVideoEncoder ctor failed.";
+    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+  }
   srand(time(NULL));
   AllowBlockingCalls();
 }
 
 int32_t MediaCodecVideoEncoder::InitEncode(
     const webrtc::VideoCodec* codec_settings,
     int32_t /* number_of_cores */,
     size_t /* max_payload_size */) {
   if (codec_settings == NULL) {
     ALOGE << "NULL VideoCodec instance";
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
   RTC_CHECK(codec_settings->codecType == codecType_)
       << "Unsupported codec " << codec_settings->codecType << " for "
       << codecType_;
-
+  if (sw_fallback_required_) {
+    return WEBRTC_VIDEO_CODEC_OK;
+  }
   codec_mode_ = codec_settings->mode;
   int init_width = codec_settings->width;
   int init_height = codec_settings->height;
   // Scaling is disabled for VP9, but optionally enabled for VP8.
   // TODO(pbos): Extract automaticResizeOn out of VP8 settings.
   scale_ = false;
   if (codecType_ == kVideoCodecVP8) {
     scale_ = codec_settings->codecSpecific.VP8.automaticResizeOn;
   } else if (codecType_ != kVideoCodecVP9) {
     scale_ = true;
@@ skipping 95 matching lines @@
   }
 
   // Call log statistics here so it's called even if no frames are being
   // delivered.
   LogStatistics(false);
 }
 
 bool MediaCodecVideoEncoder::ResetCodecOnCodecThread() {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   ALOGE << "ResetOnCodecThread";
-  if (ReleaseOnCodecThread() != WEBRTC_VIDEO_CODEC_OK ||
-      InitEncodeOnCodecThread(width_, height_, 0, 0, false) !=
-          WEBRTC_VIDEO_CODEC_OK) {
-    // TODO(fischman): wouldn't it be nice if there was a way to gracefully
-    // degrade to a SW encoder at this point?  There isn't one AFAICT :(
-    // https://code.google.com/p/webrtc/issues/detail?id=2920
+  if (ReleaseOnCodecThread() != WEBRTC_VIDEO_CODEC_OK) {
+    ALOGE << "Releasing codec failed during reset.";
+    return false;
+  }
+  if (InitEncodeOnCodecThread(width_, height_, 0, 0, false) !=
+      WEBRTC_VIDEO_CODEC_OK) {
+    ALOGE << "Initializing encoder failed during reset.";
     return false;
   }
   return true;
 }
 
+bool MediaCodecVideoEncoder::ProcessHWErrorOnCodecThread(
+    bool reset_if_fallback_unavailable) {
+  ALOGE << "ProcessHWErrorOnCodecThread";
+  if (VideoEncoder::IsSupportedSoftware(
+          VideoEncoder::CodecToEncoderType(codecType_))) {
+    ALOGE << "Fallback to SW encoder.";
+    sw_fallback_required_ = true;
+    return false;
+  } else if (reset_if_fallback_unavailable) {
+    ALOGE << "Reset encoder.";
+    return ResetCodecOnCodecThread();
+  }
+  return false;
+}
+
+int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncodeOnCodecThread() {
+  ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+  return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE
+                               : WEBRTC_VIDEO_CODEC_ERROR;
+}
+
 int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(
     int width, int height, int kbps, int fps, bool use_surface) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+  if (sw_fallback_required_) {
+    return WEBRTC_VIDEO_CODEC_OK;
+  }
   RTC_CHECK(!use_surface || egl_context_ != nullptr) << "EGL context not set.";
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   ALOGD << "InitEncodeOnCodecThread Type: " <<  (int)codecType_ << ", " <<
       width << " x " << height << ". Bitrate: " << kbps <<
       " kbps. Fps: " << fps;
   if (kbps == 0) {
     kbps = last_set_bitrate_kbps_;
   }
@@ skipping 32 matching lines @@
 
   // We enforce no extra stride/padding in the format creation step.
   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.";
+    ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    ALOGE << "Exception in init encode.";
+    ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+    return WEBRTC_VIDEO_CODEC_ERROR;
+  }
 
   if (!use_surface) {
     jobjectArray input_buffers = reinterpret_cast<jobjectArray>(
         jni->CallObjectMethod(*j_media_codec_video_encoder_,
             j_get_input_buffers_method_));
-    CHECK_EXCEPTION(jni);
-    if (IsNull(jni, input_buffers)) {
+    if (CheckException(jni)) {
+      ALOGE << "Exception in get input buffers.";
+      ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
+    if (IsNull(jni, input_buffers)) {
+      ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    }
+
     switch (GetIntField(jni, *j_media_codec_video_encoder_,
         j_color_format_field_)) {
       case COLOR_FormatYUV420Planar:
         encoder_fourcc_ = libyuv::FOURCC_YU12;
         break;
       case COLOR_FormatYUV420SemiPlanar:
       case COLOR_QCOM_FormatYUV420SemiPlanar:
       case COLOR_QCOM_FORMATYUV420PackedSemiPlanar32m:
         encoder_fourcc_ = libyuv::FOURCC_NV12;
         break;
       default:
         LOG(LS_ERROR) << "Wrong color format.";
+        ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
         return WEBRTC_VIDEO_CODEC_ERROR;
     }
     size_t num_input_buffers = jni->GetArrayLength(input_buffers);
     RTC_CHECK(input_buffers_.empty())
         << "Unexpected double InitEncode without Release";
     input_buffers_.resize(num_input_buffers);
     for (size_t i = 0; i < num_input_buffers; ++i) {
       input_buffers_[i] =
           jni->NewGlobalRef(jni->GetObjectArrayElement(input_buffers, i));
       int64_t yuv_buffer_capacity =
           jni->GetDirectBufferCapacity(input_buffers_[i]);
-      CHECK_EXCEPTION(jni);
+      if (CheckException(jni)) {
+        ALOGE << "Exception in get direct buffer capacity.";
+        ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+        return WEBRTC_VIDEO_CODEC_ERROR;
+      }
       RTC_CHECK(yuv_buffer_capacity >= yuv_size_) << "Insufficient capacity";
     }
   }
 
   inited_ = true;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(
     const webrtc::VideoFrame& frame,
     const std::vector<webrtc::FrameType>* frame_types,
     const int64_t frame_input_time_ms) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+  if (sw_fallback_required_)
+    return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
 
   bool send_key_frame = false;
   if (codec_mode_ == webrtc::kRealtimeVideo) {
     ++frames_received_since_last_key_;
     int64_t now_ms = rtc::TimeMillis();
     if (last_frame_received_ms_ != -1 &&
         (now_ms - last_frame_received_ms_) > kFrameDiffThresholdMs) {
       // Add limit to prevent triggering a key for every frame for very low
       // framerates (e.g. if frame diff > kFrameDiffThresholdMs).
       if (frames_received_since_last_key_ > kMinKeyFrameInterval) {
         ALOGD << "Send key, frame diff: " << (now_ms - last_frame_received_ms_);
         send_key_frame = true;
       }
       frames_received_since_last_key_ = 0;
     }
     last_frame_received_ms_ = now_ms;
   }
 
   frames_received_++;
   if (!DeliverPendingOutputs(jni)) {
-    if (!ResetCodecOnCodecThread())
-      return WEBRTC_VIDEO_CODEC_ERROR;
+    if (!ProcessHWErrorOnCodecThread(
+            true /* reset_if_fallback_unavailable */)) {
+      return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE
+                                   : WEBRTC_VIDEO_CODEC_ERROR;
+    }
   }
   if (frames_encoded_ < kMaxEncodedLogFrames) {
     ALOGD << "Encoder frame in # " << (frames_received_ - 1)
           << ". TS: " << (int)(current_timestamp_us_ / 1000)
           << ". Q: " << input_frame_infos_.size() << ". Fps: " << last_set_fps_
           << ". Kbps: " << last_set_bitrate_kbps_;
   }
 
   if (drop_next_input_frame_) {
     ALOGW << "Encoder drop frame - failed callback.";
@@ skipping 11 matching lines @@
   if (input_frame_infos_.size() > MAX_ENCODER_Q_SIZE) {
     ALOGD << "Already " << input_frame_infos_.size()
           << " frames in the queue, dropping"
           << ". TS: " << (int)(current_timestamp_us_ / 1000)
           << ". Fps: " << last_set_fps_
           << ". Consecutive drops: " << consecutive_full_queue_frame_drops_;
     current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
     consecutive_full_queue_frame_drops_++;
     if (consecutive_full_queue_frame_drops_ >=
         ENCODER_STALL_FRAMEDROP_THRESHOLD) {
-      ALOGE << "Encoder got stuck. Reset.";
-      ResetCodecOnCodecThread();
-      return WEBRTC_VIDEO_CODEC_ERROR;
+      ALOGE << "Encoder got stuck.";
+      return ProcessHWErrorOnEncodeOnCodecThread();
     }
     frames_dropped_media_encoder_++;
     OnDroppedFrameOnCodecThread();
     return WEBRTC_VIDEO_CODEC_OK;
   }
   consecutive_full_queue_frame_drops_ = 0;
 
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> input_buffer(
       frame.video_frame_buffer());
   if (scale_) {
@@ skipping 23 matching lines @@
     ALOGE << "Failed to reconfigure encoder.";
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   const bool key_frame =
       frame_types->front() != webrtc::kVideoFrameDelta || send_key_frame;
   bool encode_status = true;
   if (!input_frame.video_frame_buffer()->native_handle()) {
     int j_input_buffer_index = jni->CallIntMethod(*j_media_codec_video_encoder_,
         j_dequeue_input_buffer_method_);
-    CHECK_EXCEPTION(jni);
+    if (CheckException(jni)) {
+      ALOGE << "Exception in dequeu input buffer.";
+      return ProcessHWErrorOnEncodeOnCodecThread();
+    }
     if (j_input_buffer_index == -1) {
       // Video codec falls behind - no input buffer available.
       ALOGW << "Encoder drop frame - no input buffers available";
       if (frames_received_ > 1) {
         current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
         frames_dropped_media_encoder_++;
         OnDroppedFrameOnCodecThread();
       } else {
         // Input buffers are not ready after codec initialization, HW is still
         // allocating thme - this is expected and should not result in drop
         // frame report.
         frames_received_ = 0;
       }
       return WEBRTC_VIDEO_CODEC_OK;  // TODO(fischman): see webrtc bug 2887.
     } else if (j_input_buffer_index == -2) {
-      ResetCodecOnCodecThread();
-      return WEBRTC_VIDEO_CODEC_ERROR;
+      return ProcessHWErrorOnEncodeOnCodecThread();
     }
     encode_status = EncodeByteBufferOnCodecThread(jni, key_frame, input_frame,
         j_input_buffer_index);
   } else {
     encode_status = EncodeTextureOnCodecThread(jni, key_frame, input_frame);
   }
 
   if (!encode_status) {
     ALOGE << "Failed encode frame with timestamp: " << input_frame.timestamp();
-    ResetCodecOnCodecThread();
-    return WEBRTC_VIDEO_CODEC_ERROR;
+    return ProcessHWErrorOnEncodeOnCodecThread();
   }
 
   // Save input image timestamps for later output.
   input_frame_infos_.emplace_back(
       frame_input_time_ms, input_frame.timestamp(),
       input_frame.render_time_ms(), input_frame.rotation());
 
   last_input_timestamp_ms_ =
       current_timestamp_us_ / rtc::kNumMicrosecsPerMillisec;
 
   current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
 
   codec_thread_->Clear(this);
   codec_thread_->PostDelayed(RTC_FROM_HERE, kMediaCodecPollMs, this);
 
   if (!DeliverPendingOutputs(jni)) {
-    ALOGE << "Failed deliver pending outputs.";
-    ResetCodecOnCodecThread();
-    return WEBRTC_VIDEO_CODEC_ERROR;
+    return ProcessHWErrorOnEncodeOnCodecThread();
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 bool MediaCodecVideoEncoder::MaybeReconfigureEncoderOnCodecThread(
     const webrtc::VideoFrame& frame) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
 
   const bool is_texture_frame =
       frame.video_frame_buffer()->native_handle() != nullptr;
@@ skipping 27 matching lines @@
 }
 
 bool MediaCodecVideoEncoder::EncodeByteBufferOnCodecThread(JNIEnv* jni,
     bool key_frame, const webrtc::VideoFrame& frame, int input_buffer_index) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   RTC_CHECK(!use_surface_);
 
   jobject j_input_buffer = input_buffers_[input_buffer_index];
   uint8_t* yuv_buffer =
       reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_input_buffer));
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    ALOGE << "Exception in get direct buffer address.";
+    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    return false;
+  }
   RTC_CHECK(yuv_buffer) << "Indirect buffer??";
   RTC_CHECK(!libyuv::ConvertFromI420(
       frame.video_frame_buffer()->DataY(),
       frame.video_frame_buffer()->StrideY(),
       frame.video_frame_buffer()->DataU(),
       frame.video_frame_buffer()->StrideU(),
       frame.video_frame_buffer()->DataV(),
       frame.video_frame_buffer()->StrideV(),
       yuv_buffer, width_, width_, height_, encoder_fourcc_))
       << "ConvertFromI420 failed";
 
   bool encode_status = jni->CallBooleanMethod(*j_media_codec_video_encoder_,
                                               j_encode_buffer_method_,
                                               key_frame,
                                               input_buffer_index,
                                               yuv_size_,
                                               current_timestamp_us_);
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    ALOGE << "Exception in encode buffer.";
+    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    return false;
+  }
   return encode_status;
 }
 
 bool MediaCodecVideoEncoder::EncodeTextureOnCodecThread(JNIEnv* jni,
     bool key_frame, const webrtc::VideoFrame& frame) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   RTC_CHECK(use_surface_);
   NativeHandleImpl* handle = static_cast<NativeHandleImpl*>(
       frame.video_frame_buffer()->native_handle());
   jfloatArray sampling_matrix = handle->sampling_matrix.ToJava(jni);
   bool encode_status = jni->CallBooleanMethod(*j_media_codec_video_encoder_,
                                               j_encode_texture_method_,
                                               key_frame,
                                               handle->oes_texture_id,
                                               sampling_matrix,
                                               current_timestamp_us_);
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    ALOGE << "Exception in encode texture.";
+    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    return false;
+  }
   return encode_status;
 }
 
 int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread(
     webrtc::EncodedImageCallback* callback) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::ReleaseOnCodecThread() {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ALOGD << "EncoderReleaseOnCodecThread: Frames received: " <<
       frames_received_ << ". Encoded: " << frames_encoded_ <<
       ". Dropped: " << frames_dropped_media_encoder_;
   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_);
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    ALOGE << "Exception in release.";
+    ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+    return WEBRTC_VIDEO_CODEC_ERROR;
+  }
   rtc::MessageQueueManager::Clear(this);
   inited_ = false;
   use_surface_ = false;
   ALOGD << "EncoderReleaseOnCodecThread done.";
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::SetRatesOnCodecThread(uint32_t new_bit_rate,
                                                       uint32_t frame_rate) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+  if (sw_fallback_required_)
+    return WEBRTC_VIDEO_CODEC_OK;
   frame_rate = (frame_rate < MAX_ALLOWED_VIDEO_FPS) ?
       frame_rate : MAX_ALLOWED_VIDEO_FPS;
   if (last_set_bitrate_kbps_ == new_bit_rate &&
       last_set_fps_ == frame_rate) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   if (scale_) {
     quality_scaler_.ReportFramerate(frame_rate);
   }
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   if (new_bit_rate > 0) {
     last_set_bitrate_kbps_ = new_bit_rate;
   }
   if (frame_rate > 0) {
     last_set_fps_ = frame_rate;
   }
   bool ret = jni->CallBooleanMethod(*j_media_codec_video_encoder_,
                                        j_set_rates_method_,
                                        last_set_bitrate_kbps_,
                                        last_set_fps_);
-  CHECK_EXCEPTION(jni);
-  if (!ret) {
-    ResetCodecOnCodecThread();
-    return WEBRTC_VIDEO_CODEC_ERROR;
+  if (CheckException(jni) || !ret) {
+    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_OK
+                                 : WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int MediaCodecVideoEncoder::GetOutputBufferInfoIndex(
     JNIEnv* jni,
     jobject j_output_buffer_info) {
   return GetIntField(jni, j_output_buffer_info, j_info_index_field_);
 }
 
@@ skipping 15 matching lines @@
   return GetLongField(
       jni, j_output_buffer_info, j_info_presentation_timestamp_us_field_);
 }
 
 bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
 
   while (true) {
     jobject j_output_buffer_info = jni->CallObjectMethod(
         *j_media_codec_video_encoder_, j_dequeue_output_buffer_method_);
-    CHECK_EXCEPTION(jni);
+    if (CheckException(jni)) {
+      ALOGE << "Exception in set dequeue output buffer.";
+      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    }
     if (IsNull(jni, j_output_buffer_info)) {
       break;
     }
 
     int output_buffer_index =
         GetOutputBufferInfoIndex(jni, j_output_buffer_info);
     if (output_buffer_index == -1) {
-      ResetCodecOnCodecThread();
+      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
       return false;
     }
 
     // Get key and config frame flags.
     jobject j_output_buffer =
         GetOutputBufferInfoBuffer(jni, j_output_buffer_info);
     bool key_frame = GetOutputBufferInfoIsKeyFrame(jni, j_output_buffer_info);
 
     // Get frame timestamps from a queue - for non config frames only.
     int64_t encoding_start_time_ms = 0;
     int64_t frame_encoding_time_ms = 0;
     last_output_timestamp_ms_ =
         GetOutputBufferInfoPresentationTimestampUs(jni, j_output_buffer_info) /
         rtc::kNumMicrosecsPerMillisec;
     if (!input_frame_infos_.empty()) {
       const InputFrameInfo& frame_info = input_frame_infos_.front();
       output_timestamp_ = frame_info.frame_timestamp;
       output_render_time_ms_ = frame_info.frame_render_time_ms;
       output_rotation_ = frame_info.rotation;
       encoding_start_time_ms = frame_info.encode_start_time;
       input_frame_infos_.pop_front();
     }
 
     // Extract payload.
     size_t payload_size = jni->GetDirectBufferCapacity(j_output_buffer);
     uint8_t* payload = reinterpret_cast<uint8_t*>(
         jni->GetDirectBufferAddress(j_output_buffer));
-    CHECK_EXCEPTION(jni);
+    if (CheckException(jni)) {
+      ALOGE << "Exception in get direct buffer address.";
+      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    }
 
     // Callback - return encoded frame.
     int32_t callback_status = 0;
     if (callback_) {
       std::unique_ptr<webrtc::EncodedImage> image(
           new webrtc::EncodedImage(payload, payload_size, payload_size));
       image->_encodedWidth = width_;
       image->_encodedHeight = height_;
       image->_timeStamp = output_timestamp_;
       image->capture_time_ms_ = output_render_time_ms_;
@@ skipping 79 matching lines @@
           }
           scPosition += naluPosition;
           scPositions[scPositionsLength++] = scPosition;
           scPosition += H264_SC_LENGTH;
         }
         if (scPositionsLength == 0) {
           ALOGE << "Start code is not found!";
           ALOGE << "Data:" <<  image->_buffer[0] << " " << image->_buffer[1]
               << " " << image->_buffer[2] << " " << image->_buffer[3]
               << " " << image->_buffer[4] << " " << image->_buffer[5];
-          ResetCodecOnCodecThread();
+          ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
           return false;
         }
         scPositions[scPositionsLength] = payload_size;
         header.VerifyAndAllocateFragmentationHeader(scPositionsLength);
         for (size_t i = 0; i < scPositionsLength; i++) {
           header.fragmentationOffset[i] = scPositions[i] + H264_SC_LENGTH;
           header.fragmentationLength[i] =
               scPositions[i + 1] - header.fragmentationOffset[i];
           header.fragmentationPlType[i] = 0;
           header.fragmentationTimeDiff[i] = 0;
         }
       }
 
       callback_status = callback_->Encoded(*image, &info, &header);
     }
 
     // Return output buffer back to the encoder.
     bool success = jni->CallBooleanMethod(*j_media_codec_video_encoder_,
                                           j_release_output_buffer_method_,
                                           output_buffer_index);
-    CHECK_EXCEPTION(jni);
-    if (!success) {
-      ResetCodecOnCodecThread();
+    if (CheckException(jni) || !success) {
+      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
       return false;
     }
 
     // Print per frame statistics.
     if (encoding_start_time_ms > 0) {
       frame_encoding_time_ms = rtc::TimeMillis() - encoding_start_time_ms;
     }
     if (frames_encoded_ < kMaxEncodedLogFrames) {
       int current_latency =
           (int)(last_input_timestamp_ms_ - last_output_timestamp_ms_);
@@ skipping 181 matching lines @@
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni