Improve Android HW decoder error handling.

talk/app/webrtc/java/jni/androidmediadecoder_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 81 matching lines @@
  private:
   // CHECK-fail if not running on |codec_thread_|.
   void CheckOnCodecThread();
 
   int32_t InitDecodeOnCodecThread();
   int32_t ReleaseOnCodecThread();
   int32_t DecodeOnCodecThread(const EncodedImage& inputImage);
   // Deliver any outputs pending in the MediaCodec to our |callback_| and return
   // true on success.
   bool DeliverPendingOutputs(JNIEnv* jni, int dequeue_timeout_us);
+  int32_t ProcessHWErrorOnCodecThread();
 
   // Type of video codec.
   VideoCodecType codecType_;
 
   bool key_frame_required_;
   bool inited_;
+  bool sw_fallback_required_;
   bool use_surface_;
-  int error_count_;
   VideoCodec codec_;
   VideoFrame decoded_image_;
   NativeHandleImpl native_handle_;
   DecodedImageCallback* callback_;
   int frames_received_;  // Number of frames received by decoder.
   int frames_decoded_;  // Number of frames decoded by decoder.
   int64_t start_time_ms_;  // Start time for statistics.
   int current_frames_;  // Number of frames in the current statistics interval.
   int current_bytes_;  // Encoded bytes in the current statistics interval.
   int current_decoding_time_ms_;  // Overall decoding time in the current second
@@ skipping 37 matching lines @@
   std::vector<jobject> input_buffers_;
   jobject surface_texture_;
   jobject previous_surface_texture_;
 };
 
 MediaCodecVideoDecoder::MediaCodecVideoDecoder(
     JNIEnv* jni, VideoCodecType codecType) :
     codecType_(codecType),
     key_frame_required_(true),
     inited_(false),
-    error_count_(0),
+    sw_fallback_required_(false),
     surface_texture_(NULL),
     previous_surface_texture_(NULL),
     codec_thread_(new Thread()),
     j_media_codec_video_decoder_class_(
         jni,
         FindClass(jni, "org/webrtc/MediaCodecVideoDecoder")),
           j_media_codec_video_decoder_(
               jni,
               jni->NewObject(*j_media_codec_video_decoder_class_,
                    GetMethodID(jni,
                               *j_media_codec_video_decoder_class_,
                               "<init>",
                               "()V"))) {
   ScopedLocalRefFrame local_ref_frame(jni);
   codec_thread_->SetName("MediaCodecVideoDecoder", NULL);
   CHECK(codec_thread_->Start()) << "Failed to start MediaCodecVideoDecoder";
 
   j_init_decode_method_ = GetMethodID(
       jni, *j_media_codec_video_decoder_class_, "initDecode",
       "(Lorg/webrtc/MediaCodecVideoDecoder$VideoCodecType;"
-      "IIZZLandroid/opengl/EGLContext;)Z");
+      "IIZLandroid/opengl/EGLContext;)Z");
   j_release_method_ =
       GetMethodID(jni, *j_media_codec_video_decoder_class_, "release", "()V");
   j_dequeue_input_buffer_method_ = GetMethodID(
       jni, *j_media_codec_video_decoder_class_, "dequeueInputBuffer", "()I");
   j_queue_input_buffer_method_ = GetMethodID(
       jni, *j_media_codec_video_decoder_class_, "queueInputBuffer", "(IIJ)Z");
   j_dequeue_output_buffer_method_ = GetMethodID(
       jni, *j_media_codec_video_decoder_class_, "dequeueOutputBuffer",
       "(I)Lorg/webrtc/MediaCodecVideoDecoder$DecoderOutputBufferInfo;");
   j_release_output_buffer_method_ = GetMethodID(
@@ skipping 49 matching lines @@
   if (previous_surface_texture_ != NULL) {
     jni->DeleteGlobalRef(previous_surface_texture_);
   }
   if (surface_texture_ != NULL) {
     jni->DeleteGlobalRef(surface_texture_);
   }
 }
 
 int32_t MediaCodecVideoDecoder::InitDecode(const VideoCodec* inst,
     int32_t numberOfCores) {
+  ALOGD("InitDecode.");
   if (inst == NULL) {
     ALOGE("NULL VideoCodec instance");
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
   CHECK(inst->codecType == codecType_) << "Unsupported codec " <<
       inst->codecType << " for " << codecType_;
 
-  int ret_val = Release();
-  if (ret_val < 0) {
-    return ret_val;
+  if (sw_fallback_required_) {
+    ALOGE("InitDecode() - fallback to SW decoder");
+    return WEBRTC_VIDEO_CODEC_OK;
   }
   // Save VideoCodec instance for later.
   if (&codec_ != inst) {
     codec_ = *inst;
   }
   codec_.maxFramerate = (codec_.maxFramerate >= 1) ? codec_.maxFramerate : 1;
 
-  // Always start with a complete key frame.
-  key_frame_required_ = true;
-  frames_received_ = 0;
-  frames_decoded_ = 0;
-
   // Call Java init.
   return codec_thread_->Invoke<int32_t>(
       Bind(&MediaCodecVideoDecoder::InitDecodeOnCodecThread, this));
 }
 
 int32_t MediaCodecVideoDecoder::InitDecodeOnCodecThread() {
   CheckOnCodecThread();
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
-  ALOGD("InitDecodeOnCodecThread Type: %d. %d x %d. Fps: %d. Errors: %d",
+  ALOGD("InitDecodeOnCodecThread Type: %d. %d x %d. Fps: %d.",
       (int)codecType_, codec_.width, codec_.height,
-      codec_.maxFramerate, error_count_);
-  bool use_sw_codec = false;
-  if (error_count_ > 1) {
-    // If more than one critical errors happen for HW codec, switch to SW codec.
-    use_sw_codec = true;
+      codec_.maxFramerate);
+
+  // Release previous codec first if it was allocated before.
+  int ret_val = ReleaseOnCodecThread();
+  if (ret_val < 0) {
+    ALOGE("Release failure: %d - fallback to SW codec", ret_val);
+    sw_fallback_required_ = true;
+    return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
+  // Always start with a complete key frame.
+  key_frame_required_ = true;
+  frames_received_ = 0;
+  frames_decoded_ = 0;
+
   jobject j_video_codec_enum = JavaEnumFromIndex(
       jni, "MediaCodecVideoDecoder$VideoCodecType", codecType_);
   bool success = jni->CallBooleanMethod(
       *j_media_codec_video_decoder_,
       j_init_decode_method_,
       j_video_codec_enum,
       codec_.width,
       codec_.height,
-      use_sw_codec,
       use_surface_,
       MediaCodecVideoDecoderFactory::render_egl_context_);
-  CHECK_EXCEPTION(jni);
-  if (!success) {
+  if (CheckException(jni) || !success) {
+    ALOGE("Codec initialization error - fallback to SW codec.");
+    sw_fallback_required_ = true;
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   inited_ = true;
 
   switch (codecType_) {
     case kVideoCodecVP8:
       max_pending_frames_ = kMaxPendingFramesVp8;
       break;
     case kVideoCodecH264:
       max_pending_frames_ = kMaxPendingFramesH264;
@@ skipping 11 matching lines @@
   ntp_times_ms_.clear();
   frame_rtc_times_ms_.clear();
 
   jobjectArray input_buffers = (jobjectArray)GetObjectField(
       jni, *j_media_codec_video_decoder_, j_input_buffers_field_);
   size_t num_input_buffers = jni->GetArrayLength(input_buffers);
   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));
-    CHECK_EXCEPTION(jni);
+    if (CheckException(jni)) {
+      ALOGE("NewGlobalRef error - fallback to SW codec.");
+      sw_fallback_required_ = true;
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    }
   }
 
   if (use_surface_) {
     jobject surface_texture = GetObjectField(
         jni, *j_media_codec_video_decoder_, j_surface_texture_field_);
     if (previous_surface_texture_ != NULL) {
       jni->DeleteGlobalRef(previous_surface_texture_);
     }
     previous_surface_texture_ = surface_texture_;
     surface_texture_ = jni->NewGlobalRef(surface_texture);
@@ skipping 15 matching lines @@
   }
   CheckOnCodecThread();
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ALOGD("DecoderReleaseOnCodecThread: Frames received: %d.", frames_received_);
   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_decoder_, j_release_method_);
-  CHECK_EXCEPTION(jni);
+  inited_ = false;
   rtc::MessageQueueManager::Clear(this);
-  inited_ = false;
+  if (CheckException(jni)) {
+    ALOGE("Decoder release exception");
+    return WEBRTC_VIDEO_CODEC_ERROR;
+  }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void MediaCodecVideoDecoder::CheckOnCodecThread() {
   CHECK(codec_thread_ == ThreadManager::Instance()->CurrentThread())
       << "Running on wrong thread!";
 }
 
+int32_t MediaCodecVideoDecoder::ProcessHWErrorOnCodecThread() {
+  CheckOnCodecThread();
+  int ret_val = ReleaseOnCodecThread();
+  if (ret_val < 0) {
+    ALOGE("ProcessHWError: Release failure");
+  }
+  if (codecType_ == kVideoCodecH264) {
+    // For now there is no SW H.264 which can be used as fallback codec.
+    // So try to restart hw codec for now.
+    ret_val = InitDecodeOnCodecThread();
+    ALOGE("Reset H.264 codec done. Status: %d", ret_val);
+    if (ret_val == WEBRTC_VIDEO_CODEC_OK) {
+      // H.264 codec was succesfully reset - return regular error code.
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    } else {
+      // Fail to restart H.264 codec - return error code which should stop the
+      // call.
+      return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+    }
+  } else {
+    sw_fallback_required_ = true;
+    ALOGE("Return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE");
+    return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+  }
+}
+
 int32_t MediaCodecVideoDecoder::Decode(
     const EncodedImage& inputImage,
     bool missingFrames,
     const RTPFragmentationHeader* fragmentation,
     const CodecSpecificInfo* codecSpecificInfo,
     int64_t renderTimeMs) {
-  if (!inited_) {
-    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  if (sw_fallback_required_) {
+    ALOGE("Decode() - fallback to SW codec");
+    return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   }
   if (callback_ == NULL) {
+    ALOGE("Decode() - callback_ is NULL");
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (inputImage._buffer == NULL && inputImage._length > 0) {
+    ALOGE("Decode() - inputImage is incorrect");
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
+  if (!inited_) {
+    ALOGE("Decode() - decoder is not initialized");
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
+
   // Check if encoded frame dimension has changed.
   if ((inputImage._encodedWidth * inputImage._encodedHeight > 0) &&
       (inputImage._encodedWidth != codec_.width ||
       inputImage._encodedHeight != codec_.height)) {
     codec_.width = inputImage._encodedWidth;
     codec_.height = inputImage._encodedHeight;
-    InitDecode(&codec_, 1);
+    int32_t ret = InitDecode(&codec_, 1);
+    if (ret < 0) {
+      ALOGE("InitDecode failure: %d - fallback to SW codec", ret);
+      sw_fallback_required_ = true;
+      return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+    }
   }
 
   // Always start with a complete key frame.
   if (key_frame_required_) {
     if (inputImage._frameType != webrtc::kKeyFrame) {
-      ALOGE("Key frame is required");
+      ALOGE("Decode() - key frame is required");
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
     if (!inputImage._completeFrame) {
-      ALOGE("Complete frame is required");
+      ALOGE("Decode() - complete frame is required");
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
     key_frame_required_ = false;
   }
   if (inputImage._length == 0) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   return codec_thread_->Invoke<int32_t>(Bind(
       &MediaCodecVideoDecoder::DecodeOnCodecThread, this, inputImage));
 }
 
 int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
     const EncodedImage& inputImage) {
   CheckOnCodecThread();
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   // Try to drain the decoder and wait until output is not too
   // much behind the input.
   if (frames_received_ > frames_decoded_ + max_pending_frames_) {
     ALOGV("Received: %d. Decoded: %d. Wait for output...",
         frames_received_, frames_decoded_);
     if (!DeliverPendingOutputs(jni, kMediaCodecTimeoutMs * 1000)) {
-      error_count_++;
-      Reset();
-      return WEBRTC_VIDEO_CODEC_ERROR;
+      ALOGE("DeliverPendingOutputs error");
+      return ProcessHWErrorOnCodecThread();
     }
     if (frames_received_ > frames_decoded_ + max_pending_frames_) {
       ALOGE("Output buffer dequeue timeout");
-      error_count_++;
-      Reset();
-      return WEBRTC_VIDEO_CODEC_ERROR;
+      return ProcessHWErrorOnCodecThread();
     }
   }
 
   // Get input buffer.
   int j_input_buffer_index = jni->CallIntMethod(*j_media_codec_video_decoder_,
                                                 j_dequeue_input_buffer_method_);
-  CHECK_EXCEPTION(jni);
-  if (j_input_buffer_index < 0) {
+  if (CheckException(jni) || j_input_buffer_index < 0) {
     ALOGE("dequeueInputBuffer error");
-    error_count_++;
-    Reset();
-    return WEBRTC_VIDEO_CODEC_ERROR;
+    return ProcessHWErrorOnCodecThread();
   }
 
   // Copy encoded data to Java ByteBuffer.
   jobject j_input_buffer = input_buffers_[j_input_buffer_index];
   uint8* buffer =
       reinterpret_cast<uint8*>(jni->GetDirectBufferAddress(j_input_buffer));
   CHECK(buffer) << "Indirect buffer??";
   int64 buffer_capacity = jni->GetDirectBufferCapacity(j_input_buffer);
-  CHECK_EXCEPTION(jni);
-  if (buffer_capacity < inputImage._length) {
+  if (CheckException(jni) || buffer_capacity < inputImage._length) {
     ALOGE("Input frame size %d is bigger than buffer size %d.",
         inputImage._length, buffer_capacity);
-    error_count_++;
-    Reset();
-    return WEBRTC_VIDEO_CODEC_ERROR;
+    return ProcessHWErrorOnCodecThread();
   }
   jlong timestamp_us = (frames_received_ * 1000000) / codec_.maxFramerate;
   ALOGV("Decoder frame in # %d. Type: %d. Buffer # %d. TS: %lld. Size: %d",
       frames_received_, inputImage._frameType, j_input_buffer_index,
       timestamp_us / 1000, inputImage._length);
   memcpy(buffer, inputImage._buffer, inputImage._length);
 
   // Save input image timestamps for later output.
   frames_received_++;
   current_bytes_ += inputImage._length;
   timestamps_.push_back(inputImage._timeStamp);
   ntp_times_ms_.push_back(inputImage.ntp_time_ms_);
   frame_rtc_times_ms_.push_back(GetCurrentTimeMs());
 
   // Feed input to decoder.
   bool success = jni->CallBooleanMethod(*j_media_codec_video_decoder_,
                                         j_queue_input_buffer_method_,
                                         j_input_buffer_index,
                                         inputImage._length,
                                         timestamp_us);
-  CHECK_EXCEPTION(jni);
-  if (!success) {
+  if (CheckException(jni) || !success) {
     ALOGE("queueInputBuffer error");
-    error_count_++;
-    Reset();
-    return WEBRTC_VIDEO_CODEC_ERROR;
+    return ProcessHWErrorOnCodecThread();
   }
 
   // Try to drain the decoder
   if (!DeliverPendingOutputs(jni, 0)) {
     ALOGE("DeliverPendingOutputs error");
-    error_count_++;
-    Reset();
-    return WEBRTC_VIDEO_CODEC_ERROR;
+    return ProcessHWErrorOnCodecThread();
   }
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 bool MediaCodecVideoDecoder::DeliverPendingOutputs(
     JNIEnv* jni, int dequeue_timeout_us) {
   if (frames_received_ <= frames_decoded_) {
     // No need to query for output buffers - decoder is drained.
     return true;
   }
   // Get decoder output.
   jobject j_decoder_output_buffer_info = jni->CallObjectMethod(
       *j_media_codec_video_decoder_,
       j_dequeue_output_buffer_method_,
       dequeue_timeout_us);
-
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    return false;
+  }
   if (IsNull(jni, j_decoder_output_buffer_info)) {
     return true;
   }
 
   // Extract output buffer info from Java DecoderOutputBufferInfo.
   int output_buffer_index =
       GetIntField(jni, j_decoder_output_buffer_info, j_info_index_field_);
   if (output_buffer_index < 0) {
     ALOGE("dequeueOutputBuffer error : %d", output_buffer_index);
     return false;
   }
   int output_buffer_offset =
       GetIntField(jni, j_decoder_output_buffer_info, j_info_offset_field_);
   int output_buffer_size =
       GetIntField(jni, j_decoder_output_buffer_info, j_info_size_field_);
   long output_timestamps_ms = GetLongField(jni, j_decoder_output_buffer_info,
       j_info_presentation_timestamp_us_field_) / 1000;
-
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    return false;
+  }
 
   // Get decoded video frame properties.
   int color_format = GetIntField(jni, *j_media_codec_video_decoder_,
       j_color_format_field_);
   int width = GetIntField(jni, *j_media_codec_video_decoder_, j_width_field_);
   int height = GetIntField(jni, *j_media_codec_video_decoder_, j_height_field_);
   int stride = GetIntField(jni, *j_media_codec_video_decoder_, j_stride_field_);
   int slice_height = GetIntField(jni, *j_media_codec_video_decoder_,
       j_slice_height_field_);
   int texture_id = GetIntField(jni, *j_media_codec_video_decoder_,
       j_textureID_field_);
 
   // Extract data from Java ByteBuffer and create output yuv420 frame -
   // for non surface decoding only.
   if (!use_surface_) {
     if (output_buffer_size < width * height * 3 / 2) {
       ALOGE("Insufficient output buffer size: %d", output_buffer_size);
       return false;
     }
     jobjectArray output_buffers = reinterpret_cast<jobjectArray>(GetObjectField(
         jni, *j_media_codec_video_decoder_, j_output_buffers_field_));
     jobject output_buffer =
         jni->GetObjectArrayElement(output_buffers, output_buffer_index);
     uint8_t* payload = reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(
         output_buffer));
-    CHECK_EXCEPTION(jni);
+    if (CheckException(jni)) {
+      return false;
+    }
     payload += output_buffer_offset;
 
     // Create yuv420 frame.
     if (color_format == COLOR_FormatYUV420Planar) {
       decoded_image_.CreateFrame(
           payload,
           payload + (stride * slice_height),
           payload + (5 * stride * slice_height / 4),
           width, height,
           stride, stride / 2, stride / 2);
@@ skipping 31 matching lines @@
   ALOGV("Decoder frame out # %d. %d x %d. %d x %d. Color: 0x%x. TS: %ld."
       " DecTime: %lld", frames_decoded_, width, height, stride, slice_height,
       color_format, output_timestamps_ms, frame_decoding_time_ms);
 
   // Return output buffer back to codec.
   bool success = jni->CallBooleanMethod(
       *j_media_codec_video_decoder_,
       j_release_output_buffer_method_,
       output_buffer_index,
       use_surface_);
-  CHECK_EXCEPTION(jni);
-  if (!success) {
+  if (CheckException(jni) || !success) {
     ALOGE("releaseOutputBuffer error");
     return false;
   }
 
   // Calculate and print decoding statistics - every 3 seconds.
   frames_decoded_++;
   current_frames_++;
   current_decoding_time_ms_ += frame_decoding_time_ms;
   int statistic_time_ms = GetCurrentTimeMs() - start_time_ms_;
   if (statistic_time_ms >= kMediaCodecStatisticsIntervalMs &&
@@ skipping 49 matching lines @@
   if (!inited_) {
     return;
   }
   // We only ever send one message to |this| directly (not through a Bind()'d
   // functor), so expect no ID/data.
   CHECK(!msg->message_id) << "Unexpected message!";
   CHECK(!msg->pdata) << "Unexpected message!";
   CheckOnCodecThread();
 
   if (!DeliverPendingOutputs(jni, 0)) {
-    error_count_++;
-    Reset();
+    ALOGE("OnMessage: DeliverPendingOutputs error");
+    ProcessHWErrorOnCodecThread();
+    return;
   }
   codec_thread_->PostDelayed(kMediaCodecPollMs, this);
 }
 
 int MediaCodecVideoDecoderFactory::SetAndroidObjects(JNIEnv* jni,
     jobject render_egl_context) {
   ALOGD("SetAndroidObjects for surface decoding.");
   if (render_egl_context_) {
     jni->DeleteGlobalRef(render_egl_context_);
   }
   if (IsNull(jni, render_egl_context)) {
     render_egl_context_ = NULL;
   } else {
     render_egl_context_ = jni->NewGlobalRef(render_egl_context);
-    CHECK_EXCEPTION(jni) << "error calling NewGlobalRef for EGL Context.";
-    jclass j_egl_context_class = FindClass(jni, "android/opengl/EGLContext");
-    if (!jni->IsInstanceOf(render_egl_context_, j_egl_context_class)) {
-      ALOGE("Wrong EGL Context.");
-      jni->DeleteGlobalRef(render_egl_context_);
+    if (CheckException(jni)) {
+      ALOGE("error calling NewGlobalRef for EGL Context.");
       render_egl_context_ = NULL;
+    } else {
+      jclass j_egl_context_class = FindClass(jni, "android/opengl/EGLContext");
+      if (!jni->IsInstanceOf(render_egl_context_, j_egl_context_class)) {
+        ALOGE("Wrong EGL Context.");
+        jni->DeleteGlobalRef(render_egl_context_);
+        render_egl_context_ = NULL;
+      }
     }
   }
   if (render_egl_context_ == NULL) {
     ALOGD("NULL VideoDecoder EGL context - HW surface decoding is disabled.");
   }
   return 0;
 }
 
 MediaCodecVideoDecoderFactory::MediaCodecVideoDecoderFactory() {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_decoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoDecoder");
   supported_codec_types_.clear();
 
   bool is_vp8_hw_supported = jni->CallStaticBooleanMethod(
       j_decoder_class,
       GetStaticMethodID(jni, j_decoder_class, "isVp8HwSupported", "()Z"));
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    is_vp8_hw_supported = false;
+  }
   if (is_vp8_hw_supported) {
     ALOGD("VP8 HW Decoder supported.");
     supported_codec_types_.push_back(kVideoCodecVP8);
   }
 
   bool is_h264_hw_supported = jni->CallStaticBooleanMethod(
       j_decoder_class,
       GetStaticMethodID(jni, j_decoder_class, "isH264HwSupported", "()Z"));
-  CHECK_EXCEPTION(jni);
+  if (CheckException(jni)) {
+    is_h264_hw_supported = false;
+  }
   if (is_h264_hw_supported) {
     ALOGD("H264 HW Decoder supported.");
     supported_codec_types_.push_back(kVideoCodecH264);
   }
 }
 
 MediaCodecVideoDecoderFactory::~MediaCodecVideoDecoderFactory() {}
 
 webrtc::VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
     VideoCodecType type) {
@@ skipping 11 matching lines @@
   return NULL;
 }
 
 void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(
     webrtc::VideoDecoder* decoder) {
   delete decoder;
 }
 
 }  // namespace webrtc_jni