Add an option to soft reset HW decoder.

webrtc/api/java/jni/androidmediadecoder_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 81 matching lines @@
   // rtc::MessageHandler implementation.
   void OnMessage(rtc::Message* msg) override;
 
   const char* ImplementationName() const override;
 
  private:
   // CHECK-fail if not running on |codec_thread_|.
   void CheckOnCodecThread();
 
   int32_t InitDecodeOnCodecThread();
+  int32_t SoftResetDecodeOnCodecThread();
   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();
   void EnableFrameLogOnWarning();
 
   // Type of video codec.
   VideoCodecType codecType_;
@@ skipping 20 matching lines @@
   int current_decoding_time_ms_;  // Overall decoding time in the current second
   int current_delay_time_ms_;  // Overall delay time in the current second.
   uint32_t max_pending_frames_;  // Maximum number of pending input frames.
 
   // State that is constant for the lifetime of this object once the ctor
   // returns.
   scoped_ptr<Thread> codec_thread_;  // Thread on which to operate MediaCodec.
   ScopedGlobalRef<jclass> j_media_codec_video_decoder_class_;
   ScopedGlobalRef<jobject> j_media_codec_video_decoder_;
   jmethodID j_init_decode_method_;
+  jmethodID j_soft_reset_decode_method_;
   jmethodID j_release_method_;
   jmethodID j_dequeue_input_buffer_method_;
   jmethodID j_queue_input_buffer_method_;
   jmethodID j_dequeue_byte_buffer_method_;
   jmethodID j_dequeue_texture_buffer_method_;
   jmethodID j_return_decoded_byte_buffer_method_;
   // MediaCodecVideoDecoder fields.
   jfieldID j_input_buffers_field_;
   jfieldID j_output_buffers_field_;
   jfieldID j_color_format_field_;
@@ skipping 41 matching lines @@
                               "<init>",
                               "()V"))) {
   ScopedLocalRefFrame local_ref_frame(jni);
   codec_thread_->SetName("MediaCodecVideoDecoder", NULL);
   RTC_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;"
       "IILorg/webrtc/SurfaceTextureHelper;)Z");
+  j_soft_reset_decode_method_ = GetMethodID(
+      jni, *j_media_codec_video_decoder_class_, "softResetDecode", "(II)V");
   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", "(IIJJJ)Z");
   j_dequeue_byte_buffer_method_ = GetMethodID(
       jni, *j_media_codec_video_decoder_class_, "dequeueOutputBuffer",
       "(I)Lorg/webrtc/MediaCodecVideoDecoder$DecodedOutputBuffer;");
   j_dequeue_texture_buffer_method_ = GetMethodID(
@@ skipping 152 matching lines @@
       break;
     case kVideoCodecVP9:
       max_pending_frames_ = kMaxPendingFramesVp9;
       break;
     case kVideoCodecH264:
       max_pending_frames_ = kMaxPendingFramesH264;
       break;
     default:
       max_pending_frames_ = 0;
   }
+  ALOGD << "Maximum amount of pending frames: " << max_pending_frames_;
+
   start_time_ms_ = GetCurrentTimeMs();
   current_frames_ = 0;
   current_bytes_ = 0;
   current_decoding_time_ms_ = 0;
   current_delay_time_ms_ = 0;
 
   jobjectArray input_buffers = (jobjectArray)GetObjectField(
       jni, *j_media_codec_video_decoder_, j_input_buffers_field_);
   size_t num_input_buffers = jni->GetArrayLength(input_buffers);
-  ALOGD << "Maximum amount of pending frames: " << max_pending_frames_;
   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));
     if (CheckException(jni)) {
       ALOGE << "NewGlobalRef error - fallback to SW codec.";
       sw_fallback_required_ = true;
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
   }
 
   codec_thread_->PostDelayed(kMediaCodecPollMs, this);
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
 

[perkj_webrtc, 2016/03/02 12:33:22]

ResetDecodeOnCodecThread?

[AlexG, 2016/03/04 01:20:20]

Done.

+int32_t MediaCodecVideoDecoder::SoftResetDecodeOnCodecThread() {
+  CheckOnCodecThread();
+  JNIEnv* jni = AttachCurrentThreadIfNeeded();
+  ScopedLocalRefFrame local_ref_frame(jni);
+  ALOGD << "SoftResetDecodeOnCodecThread Type: " << (int)codecType_ << ". "
+      << codec_.width << " x " << codec_.height;
+  ALOGD << "  Frames received: " << frames_received_ <<
+      ". Frames decoded: " << frames_decoded_;
+
+  inited_ = false;
+  rtc::MessageQueueManager::Clear(this);
+
+  // Always start with a complete key frame.
+  key_frame_required_ = true;

[perkj_webrtc, 2016/03/02 12:33:22]

Move all these to a helper method and call from InitDecodeOnCodecThread as well
please. Call it ResetState or something ? 

[AlexG, 2016/03/04 01:20:20]

Done.

+  frames_received_ = 0;
+  frames_decoded_ = 0;
+  frames_decoded_logged_ = kMaxDecodedLogFrames;
+  start_time_ms_ = GetCurrentTimeMs();
+  current_frames_ = 0;
+  current_bytes_ = 0;
+  current_decoding_time_ms_ = 0;
+  current_delay_time_ms_ = 0;
+
+  jni->CallVoidMethod(
+      *j_media_codec_video_decoder_,
+      j_soft_reset_decode_method_,
+      codec_.width,
+      codec_.height);
+
+  if (CheckException(jni)) {
+    ALOGE << "Soft reset error - fallback to SW codec.";
+    sw_fallback_required_ = true;
+    return WEBRTC_VIDEO_CODEC_ERROR;
+  }
+  inited_ = true;
+
+  codec_thread_->PostDelayed(kMediaCodecPollMs, this);
+
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
 int32_t MediaCodecVideoDecoder::Release() {
   ALOGD << "DecoderRelease request";
   return codec_thread_->Invoke<int32_t>(
         Bind(&MediaCodecVideoDecoder::ReleaseOnCodecThread, this));
 }
 
 int32_t MediaCodecVideoDecoder::ReleaseOnCodecThread() {
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
@@ skipping 75 matching lines @@
   }
   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)) {
+    ALOGW << "Input resolution changed from " <<
+        codec_.width << " x " << codec_.height << " to " <<
+        inputImage._encodedWidth << " x " << inputImage._encodedHeight;
     codec_.width = inputImage._encodedWidth;
     codec_.height = inputImage._encodedHeight;
-    int32_t ret = InitDecode(&codec_, 1);
+    int32_t ret;
+    if (use_surface_ && codecType_ == kVideoCodecVP8) {
+      // Soft codec reset - only for VP8 and surface decoding.
+      // TODO(glaznev): try to use similar approach for H.264.
+      ret = codec_thread_->Invoke<int32_t>(Bind(
+          &MediaCodecVideoDecoder::SoftResetDecodeOnCodecThread, this));
+    } else {
+      // Hard codec reset.
+      ret = InitDecode(&codec_, 1);
+    }
     if (ret < 0) {
       ALOGE << "InitDecode failure: " << ret << " - fallback to SW codec";
       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::kVideoFrameKey) {
@@ skipping 419 matching lines @@
   ALOGD << "Destroy video decoder.";
   delete decoder;
 }
 
 const char* MediaCodecVideoDecoder::ImplementationName() const {
   return "MediaCodec";
 }
 
 }  // namespace webrtc_jni