Remove codec thread from 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.
  */
 
 // NOTICE: androidmediaencoder_jni.h must be included before
 // androidmediacodeccommon.h to avoid build errors.
 #include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
 
 #include <algorithm>
 #include <memory>
 #include <list>
 
 #include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/libyuv/include/libyuv/convert_from.h"
 #include "third_party/libyuv/include/libyuv/video_common.h"
 #include "webrtc/sdk/android/src/jni/androidmediacodeccommon.h"
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 #include "webrtc/sdk/android/src/jni/native_handle_impl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/sequenced_task_checker.h"
+#include "webrtc/base/task_queue.h"
 #include "webrtc/base/thread.h"
-#include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timeutils.h"
+#include "webrtc/base/weak_ptr.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/h264/h264_bitstream_parser.h"
 #include "webrtc/common_video/h264/h264_common.h"
 #include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/media/engine/internalencoderfactory.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/quality_scaler.h"
 #include "webrtc/modules/video_coding/utility/vp8_header_parser.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
@@ skipping 42 matching lines @@
 // Maximum time limit between incoming frames before requesting a key frame.
 const size_t kFrameDiffThresholdMs = 350;
 const int kMinKeyFrameInterval = 6;
 const char kH264HighProfileFieldTrial[] = "WebRTC-H264HighProfile";
 }  // namespace
 
 // MediaCodecVideoEncoder is a webrtc::VideoEncoder implementation that uses
 // Android's MediaCodec SDK API behind the scenes to implement (hopefully)
 // HW-backed video encode.  This C++ class is implemented as a very thin shim,
 // delegating all of the interesting work to org.webrtc.MediaCodecVideoEncoder.
-// MediaCodecVideoEncoder is created, operated, and destroyed on a single
-// thread, currently the libjingle Worker thread.
-class MediaCodecVideoEncoder : public webrtc::VideoEncoder,
-                               public rtc::MessageHandler {
+// MediaCodecVideoEncoder must be operated on a single task queue, currently
+// this is the encoder queue from ViE encoder.
+class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
  public:
   virtual ~MediaCodecVideoEncoder();
   MediaCodecVideoEncoder(JNIEnv* jni,
                          const cricket::VideoCodec& codec,
                          jobject egl_context);
 
-  // webrtc::VideoEncoder implementation.  Everything trampolines to
-  // |codec_thread_| for execution.
+  // webrtc::VideoEncoder implementation.
   int32_t InitEncode(const webrtc::VideoCodec* codec_settings,
                      int32_t /* number_of_cores */,
                      size_t /* max_payload_size */) override;
   int32_t Encode(const webrtc::VideoFrame& input_image,
                  const webrtc::CodecSpecificInfo* /* codec_specific_info */,
                  const std::vector<webrtc::FrameType>* frame_types) override;
   int32_t RegisterEncodeCompleteCallback(
       webrtc::EncodedImageCallback* callback) override;
   int32_t Release() override;
   int32_t SetChannelParameters(uint32_t /* packet_loss */,
                                int64_t /* rtt */) override;
   int32_t SetRateAllocation(const webrtc::BitrateAllocation& rate_allocation,
                             uint32_t frame_rate) override;
 
-  // rtc::MessageHandler implementation.
-  void OnMessage(rtc::Message* msg) 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();
+  class EncodeTask : public rtc::QueuedTask {
+   public:
+    EncodeTask(rtc::WeakPtr<MediaCodecVideoEncoder> encoder);
+    bool Run() override;
+
+   private:
+    rtc::WeakPtr<MediaCodecVideoEncoder> encoder_;
+  };
+
+  // ResetCodec() calls Release() and InitEncodeInternal() 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 ResetCodec();
 
   // 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);
+  bool ProcessHWError(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();
+  // Calls ProcessHWError(true). Returns WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE if
+  // sw_fallback_required_ was set or WEBRTC_VIDEO_CODEC_ERROR otherwise.
+  int32_t ProcessHWErrorOnEncode();
 
-  // 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);
+  int32_t InitEncodeInternal(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
   // for byte buffer/texture. Returns false if reconfiguring fails.
-  bool MaybeReconfigureEncoderOnCodecThread(const webrtc::VideoFrame& frame);
-  int32_t EncodeOnCodecThread(
-      const webrtc::VideoFrame& input_image,
-      const std::vector<webrtc::FrameType>* frame_types,
-      const int64_t frame_input_time_ms);
-  bool EncodeByteBufferOnCodecThread(JNIEnv* jni,
-      bool key_frame, const webrtc::VideoFrame& frame, int input_buffer_index);
-  bool EncodeTextureOnCodecThread(JNIEnv* jni,
-      bool key_frame, const webrtc::VideoFrame& frame);
-
-  int32_t RegisterEncodeCompleteCallbackOnCodecThread(
-      webrtc::EncodedImageCallback* callback);
-  int32_t ReleaseOnCodecThread();
-  int32_t SetRatesOnCodecThread(uint32_t new_bit_rate, uint32_t frame_rate);
+  bool MaybeReconfigureEncoder(const webrtc::VideoFrame& frame);
+  bool EncodeByteBuffer(JNIEnv* jni,
+                        bool key_frame,
+                        const webrtc::VideoFrame& frame,
+                        int input_buffer_index);
+  bool EncodeTexture(JNIEnv* jni,
+                     bool key_frame,
+                     const webrtc::VideoFrame& frame);
 
   // Helper accessors for MediaCodecVideoEncoder$OutputBufferInfo members.
   int GetOutputBufferInfoIndex(JNIEnv* jni, jobject j_output_buffer_info);
   jobject GetOutputBufferInfoBuffer(JNIEnv* jni, jobject j_output_buffer_info);
   bool GetOutputBufferInfoIsKeyFrame(JNIEnv* jni, jobject j_output_buffer_info);
   jlong GetOutputBufferInfoPresentationTimestampUs(
       JNIEnv* jni, jobject j_output_buffer_info);
 
   // Deliver any outputs pending in the MediaCodec to our |callback_| and return
   // true on success.
   bool DeliverPendingOutputs(JNIEnv* jni);
 
   VideoEncoder::ScalingSettings GetScalingSettings() const override;
 
   // Displays encoder statistics.
   void LogStatistics(bool force_log);
 
+#if RTC_DCHECK_IS_ON
+  // Mutex for protecting inited_. It is only used for correctness checking on
+  // debug build. It is used for checking that encoder has been released in the
+  // destructor. Because this might happen on a different thread, we need a
+  // mutex.
+  rtc::CriticalSection inited_crit_;
+#endif
+
   // Type of video codec.
   const cricket::VideoCodec codec_;
 
-  // Valid all the time since RegisterEncodeCompleteCallback() Invoke()s to
-  // |codec_thread_| synchronously.
   webrtc::EncodedImageCallback* callback_;
 
   // State that is constant for the lifetime of this object once the ctor
   // returns.
-  std::unique_ptr<Thread>
-      codec_thread_;  // Thread on which to operate MediaCodec.
-  rtc::ThreadChecker codec_thread_checker_;
+  rtc::SequencedTaskChecker encoder_queue_checker_;
   ScopedGlobalRef<jclass> j_media_codec_video_encoder_class_;
   ScopedGlobalRef<jobject> j_media_codec_video_encoder_;
   jmethodID j_init_encode_method_;
   jmethodID j_get_input_buffers_method_;
   jmethodID j_dequeue_input_buffer_method_;
   jmethodID j_encode_buffer_method_;
   jmethodID j_encode_texture_method_;
   jmethodID j_release_method_;
   jmethodID j_set_rates_method_;
   jmethodID j_dequeue_output_buffer_method_;
   jmethodID j_release_output_buffer_method_;
   jfieldID j_color_format_field_;
   jfieldID j_info_index_field_;
   jfieldID j_info_buffer_field_;
   jfieldID j_info_is_key_frame_field_;
   jfieldID j_info_presentation_timestamp_us_field_;
 
   // State that is valid only between InitEncode() and the next Release().
-  // Touched only on codec_thread_ so no explicit synchronization necessary.
   int width_;   // Frame width in pixels.
   int height_;  // Frame height in pixels.
   bool inited_;
   bool use_surface_;
   uint16_t picture_id_;
   enum libyuv::FourCC encoder_fourcc_;  // Encoder color space format.
   int last_set_bitrate_kbps_;  // Last-requested bitrate in kbps.
   int last_set_fps_;  // Last-requested frame rate.
   int64_t current_timestamp_us_;  // Current frame timestamps in us.
   int frames_received_;  // Number of frames received by encoder.
   int frames_encoded_;  // Number of frames encoded by encoder.
   int frames_dropped_media_encoder_;  // Number of frames dropped by encoder.
   // Number of dropped frames caused by full queue.
   int consecutive_full_queue_frame_drops_;
   int64_t stat_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_acc_qp_; // Accumulated QP in the current statistics interval.
   int current_encoding_time_ms_;  // Overall encoding time in the current second
   int64_t last_input_timestamp_ms_;  // Timestamp of last received yuv frame.
   int64_t last_output_timestamp_ms_;  // Timestamp of last encoded frame.
+  // Holds the task while the polling loop is paused.
+  std::unique_ptr<rtc::QueuedTask> encode_task_;
 
   struct InputFrameInfo {
     InputFrameInfo(int64_t encode_start_time,
                    int32_t frame_timestamp,
                    int64_t frame_render_time_ms,
                    webrtc::VideoRotation rotation)
         : encode_start_time(encode_start_time),
           frame_timestamp(frame_timestamp),
           frame_render_time_ms(frame_render_time_ms),
           rotation(rotation) {}
@@ skipping 33 matching lines @@
   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_;
+
+  // All other member variables should be before WeakPtrFactory. Valid only from
+  // InitEncode to Release.
+  std::unique_ptr<rtc::WeakPtrFactory<MediaCodecVideoEncoder>> weak_factory_;
 };
 
 MediaCodecVideoEncoder::~MediaCodecVideoEncoder() {
-  // Call Release() to ensure no more callbacks to us after we are deleted.
-  Release();
+#if RTC_DCHECK_IS_ON

[stefan-webrtc, 2017/02/21 12:29:56]

I haven't seen this in many other places. Why is it needed here?

[sakal, 2017/02/21 12:53:50]

A lock is not normally needed. However, it is needed for this debug check. I
didn't want to add it for release builds just to make a debug check.

[stefan-webrtc, 2017/02/21 13:13:08]

ack

+  rtc::CritScope lock(&inited_crit_);
+  RTC_DCHECK(!inited_);
+#endif
 }
 
 MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni,
                                                const cricket::VideoCodec& codec,
                                                jobject egl_context)
     : codec_(codec),
       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) {
-  // 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";
-  codec_thread_checker_.DetachFromThread();
+  encoder_queue_checker_.Detach();
+
   jclass j_output_buffer_info_class =
       FindClass(jni, "org/webrtc/MediaCodecVideoEncoder$OutputBufferInfo");
   j_init_encode_method_ = GetMethodID(
       jni,
       *j_media_codec_video_encoder_class_,
       "initEncode",
       "(Lorg/webrtc/MediaCodecVideoEncoder$VideoCodecType;"
       "IIIILorg/webrtc/EglBase14$Context;)Z");
   j_get_input_buffers_method_ = GetMethodID(
       jni,
@@ skipping 24 matching lines @@
   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");
   if (CheckException(jni)) {
     ALOGW << "MediaCodecVideoEncoder ctor failed.";
-    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    ProcessHWError(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 */) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (codec_settings == NULL) {
     ALOGE << "NULL VideoCodec instance";
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
   const VideoCodecType codec_type = webrtc::PayloadNameToCodecType(codec_.name)
                                         .value_or(webrtc::kVideoCodecUnknown);
   RTC_CHECK(codec_settings->codecType == codec_type)
       << "Unsupported codec " << codec_settings->codecType << " for "
       << codec_type;
   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 (codec_type == kVideoCodecVP8) {
     scale_ = codec_settings->VP8().automaticResizeOn;
   } else if (codec_type != kVideoCodecVP9) {
     scale_ = true;
   }
 
   ALOGD << "InitEncode request: " << init_width << " x " << init_height;
   ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled");
 
-  return codec_thread_->Invoke<int32_t>(
-      RTC_FROM_HERE,
-      Bind(&MediaCodecVideoEncoder::InitEncodeOnCodecThread, this, init_width,
-           init_height, codec_settings->startBitrate,
-           codec_settings->maxFramerate,
-           codec_settings->expect_encode_from_texture));
-}
-
-int32_t MediaCodecVideoEncoder::Encode(
-    const webrtc::VideoFrame& frame,
-    const webrtc::CodecSpecificInfo* /* codec_specific_info */,
-    const std::vector<webrtc::FrameType>* frame_types) {
-  return codec_thread_->Invoke<int32_t>(
-      RTC_FROM_HERE, Bind(&MediaCodecVideoEncoder::EncodeOnCodecThread, this,
-                          frame, frame_types, rtc::TimeMillis()));
-}
-
-int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
-    webrtc::EncodedImageCallback* callback) {
-  return codec_thread_->Invoke<int32_t>(
-      RTC_FROM_HERE,
-      Bind(&MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread,
-           this, callback));
-}
-
-int32_t MediaCodecVideoEncoder::Release() {
-  ALOGD << "EncoderRelease request";
-  return codec_thread_->Invoke<int32_t>(
-      RTC_FROM_HERE, Bind(&MediaCodecVideoEncoder::ReleaseOnCodecThread, this));
+  return InitEncodeInternal(
+      init_width, init_height, codec_settings->startBitrate,
+      codec_settings->maxFramerate, codec_settings->expect_encode_from_texture);
 }
 
 int32_t MediaCodecVideoEncoder::SetChannelParameters(uint32_t /* packet_loss */,
                                                      int64_t /* rtt */) {
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-int32_t MediaCodecVideoEncoder::SetRateAllocation(
-    const webrtc::BitrateAllocation& rate_allocation,
-    uint32_t frame_rate) {
-  return codec_thread_->Invoke<int32_t>(
-      RTC_FROM_HERE, Bind(&MediaCodecVideoEncoder::SetRatesOnCodecThread, this,
-                          rate_allocation.get_sum_kbps(), frame_rate));
-}
-
-void MediaCodecVideoEncoder::OnMessage(rtc::Message* msg) {
-  RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
-  JNIEnv* jni = AttachCurrentThreadIfNeeded();
-  ScopedLocalRefFrame local_ref_frame(jni);
-
-  // We only ever send one message to |this| directly (not through a Bind()'d
-  // functor), so expect no ID/data.
-  RTC_CHECK(!msg->message_id) << "Unexpected message!";
-  RTC_CHECK(!msg->pdata) << "Unexpected message!";
-  if (!inited_) {
-    return;
-  }
-
-  // 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.
-  DeliverPendingOutputs(jni);
-
-  // If there aren't more frames to deliver, we can start polling at lower rate.
-  if (input_frame_infos_.empty()) {
-    codec_thread_->PostDelayed(RTC_FROM_HERE, kMediaCodecPollNoFramesMs, this);
-  } else {
-    codec_thread_->PostDelayed(RTC_FROM_HERE, kMediaCodecPollMs, this);
-  }
-
-  // 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) {
+bool MediaCodecVideoEncoder::ResetCodec() {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
+  ALOGE << "Reset";
+  if (Release() != WEBRTC_VIDEO_CODEC_OK) {
     ALOGE << "Releasing codec failed during reset.";
     return false;
   }
-  if (InitEncodeOnCodecThread(width_, height_, 0, 0, false) !=
+  if (InitEncodeInternal(width_, height_, 0, 0, false) !=
       WEBRTC_VIDEO_CODEC_OK) {
     ALOGE << "Initializing encoder failed during reset.";
     return false;
   }
   return true;
 }
 
-bool MediaCodecVideoEncoder::ProcessHWErrorOnCodecThread(
+MediaCodecVideoEncoder::EncodeTask::EncodeTask(
+    rtc::WeakPtr<MediaCodecVideoEncoder> encoder)
+    : encoder_(encoder) {}
+
+bool MediaCodecVideoEncoder::EncodeTask::Run() {
+  if (!encoder_) {
+    // Encoder was destroyed.
+    return true;
+  }
+
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_->encoder_queue_checker_);
+  JNIEnv* jni = AttachCurrentThreadIfNeeded();
+  ScopedLocalRefFrame local_ref_frame(jni);
+
+  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);
+
+  // 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(
+        std::unique_ptr<rtc::QueuedTask>(this), kMediaCodecPollMs);
+  }
+
+  return false;
+}
+
+bool MediaCodecVideoEncoder::ProcessHWError(
     bool reset_if_fallback_unavailable) {
-  ALOGE << "ProcessHWErrorOnCodecThread";
+  ALOGE << "ProcessHWError";
   if (FindMatchingCodec(cricket::InternalEncoderFactory().supported_codecs(),
                         codec_)) {
     ALOGE << "Fallback to SW encoder.";
     sw_fallback_required_ = true;
     return false;
   } else if (reset_if_fallback_unavailable) {
     ALOGE << "Reset encoder.";
-    return ResetCodecOnCodecThread();
+    return ResetCodec();
   }
   return false;
 }
 
-int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncodeOnCodecThread() {
-  ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncode() {
+  ProcessHWError(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());
+int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
+                                                   int height,
+                                                   int kbps,
+                                                   int fps,
+                                                   bool use_surface) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   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);
 
   const VideoCodecType codec_type = webrtc::PayloadNameToCodecType(codec_.name)
                                         .value_or(webrtc::kVideoCodecUnknown);
-  ALOGD << "InitEncodeOnCodecThread Type: " << (int)codec_type << ", " << width
+  ALOGD << "InitEncodeInternal Type: " << (int)codec_type << ", " << width
         << " x " << height << ". Bitrate: " << kbps << " kbps. Fps: " << fps;
   if (kbps == 0) {
     kbps = last_set_bitrate_kbps_;
   }
   if (fps == 0) {
     fps = MAX_VIDEO_FPS;
   }
 
   width_ = width;
   height_ = height;
@@ skipping 16 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.";
-    ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+    ProcessHWError(false /* reset_if_fallback_unavailable */);
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   if (CheckException(jni)) {
     ALOGE << "Exception in init encode.";
-    ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+    ProcessHWError(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_));
     if (CheckException(jni)) {
       ALOGE << "Exception in get input buffers.";
-      ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+      ProcessHWError(false /* reset_if_fallback_unavailable */);
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     if (IsNull(jni, input_buffers)) {
-      ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+      ProcessHWError(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 */);
+        ProcessHWError(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]);
       if (CheckException(jni)) {
         ALOGE << "Exception in get direct buffer capacity.";
-        ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+        ProcessHWError(false /* reset_if_fallback_unavailable */);
         return WEBRTC_VIDEO_CODEC_ERROR;
       }
       RTC_CHECK(yuv_buffer_capacity >= yuv_size_) << "Insufficient capacity";
     }
   }
 
-  inited_ = true;
+  {
+#if RTC_DCHECK_IS_ON
+    rtc::CritScope lock(&inited_crit_);
+#endif
+    inited_ = true;
+  }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(
+int32_t MediaCodecVideoEncoder::Encode(
     const webrtc::VideoFrame& frame,
-    const std::vector<webrtc::FrameType>* frame_types,
-    const int64_t frame_input_time_ms) {
-  RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+    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;
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
+  const int64_t frame_input_time_ms = rtc::TimeMillis();
 
   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 (!ProcessHWErrorOnCodecThread(
-            true /* reset_if_fallback_unavailable */)) {
+    if (!ProcessHWError(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_;
   }
@@ skipping 14 matching lines @@
     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.";
-      return ProcessHWErrorOnEncodeOnCodecThread();
+      return ProcessHWErrorOnEncode();
     }
     frames_dropped_media_encoder_++;
     return WEBRTC_VIDEO_CODEC_OK;
   }
   consecutive_full_queue_frame_drops_ = 0;
 
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> input_buffer(
       frame.video_frame_buffer());
 
   VideoFrame input_frame(input_buffer, frame.timestamp(),
                          frame.render_time_ms(), frame.rotation());
 
-  if (!MaybeReconfigureEncoderOnCodecThread(input_frame)) {
+  if (!MaybeReconfigureEncoder(input_frame)) {
     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_);
+    int j_input_buffer_index = jni->CallIntMethod(
+        *j_media_codec_video_encoder_, j_dequeue_input_buffer_method_);
     if (CheckException(jni)) {
       ALOGE << "Exception in dequeu input buffer.";
-      return ProcessHWErrorOnEncodeOnCodecThread();
+      return ProcessHWErrorOnEncode();
     }
     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_++;
       } 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) {
-      return ProcessHWErrorOnEncodeOnCodecThread();
+      return ProcessHWErrorOnEncode();
     }
-    encode_status = EncodeByteBufferOnCodecThread(jni, key_frame, input_frame,
-        j_input_buffer_index);
+    encode_status =
+        EncodeByteBuffer(jni, key_frame, input_frame, j_input_buffer_index);
   } else {
-    encode_status = EncodeTextureOnCodecThread(jni, key_frame, input_frame);
+    encode_status = EncodeTexture(jni, key_frame, input_frame);
   }
 
   if (!encode_status) {
     ALOGE << "Failed encode frame with timestamp: " << input_frame.timestamp();
-    return ProcessHWErrorOnEncodeOnCodecThread();
+    return ProcessHWErrorOnEncode();
   }
 
   // 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());
+  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);
+  // Start the polling loop if it is not started.
+  if (encode_task_) {
+    rtc::TaskQueue::Current()->PostDelayedTask(std::move(encode_task_),
+                                               kMediaCodecPollMs);
+  }
 
   if (!DeliverPendingOutputs(jni)) {
-    return ProcessHWErrorOnEncodeOnCodecThread();
+    return ProcessHWErrorOnEncode();
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-bool MediaCodecVideoEncoder::MaybeReconfigureEncoderOnCodecThread(
+bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(
     const webrtc::VideoFrame& frame) {
-  RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
 
   const bool is_texture_frame =
       frame.video_frame_buffer()->native_handle() != nullptr;
   const bool reconfigure_due_to_format = is_texture_frame != use_surface_;
   const bool reconfigure_due_to_size =
       frame.width() != width_ || frame.height() != height_;
 
   if (reconfigure_due_to_format) {
       ALOGD << "Reconfigure encoder due to format change. "
             << (use_surface_ ?
                 "Reconfiguring to encode from byte buffer." :
                 "Reconfiguring to encode from texture.");
       LogStatistics(true);
   }
   if (reconfigure_due_to_size) {
     ALOGW << "Reconfigure encoder due to frame resolution change from "
         << width_ << " x " << height_ << " to " << frame.width() << " x "
         << frame.height();
     LogStatistics(true);
     width_ = frame.width();
     height_ = frame.height();
   }
 
   if (!reconfigure_due_to_format && !reconfigure_due_to_size)
     return true;
 
-  ReleaseOnCodecThread();
+  Release();
 
-  return InitEncodeOnCodecThread(width_, height_, 0, 0 , is_texture_frame) ==
-      WEBRTC_VIDEO_CODEC_OK;
+  return InitEncodeInternal(width_, height_, 0, 0, is_texture_frame) ==
+         WEBRTC_VIDEO_CODEC_OK;
 }
 
-bool MediaCodecVideoEncoder::EncodeByteBufferOnCodecThread(JNIEnv* jni,
-    bool key_frame, const webrtc::VideoFrame& frame, int input_buffer_index) {
-  RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+bool MediaCodecVideoEncoder::EncodeByteBuffer(JNIEnv* jni,
+                                              bool key_frame,
+                                              const webrtc::VideoFrame& frame,
+                                              int input_buffer_index) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   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));
   if (CheckException(jni)) {
     ALOGE << "Exception in get direct buffer address.";
-    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    ProcessHWError(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_);
   if (CheckException(jni)) {
     ALOGE << "Exception in encode buffer.";
-    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    ProcessHWError(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());
+bool MediaCodecVideoEncoder::EncodeTexture(JNIEnv* jni,
+                                           bool key_frame,
+                                           const webrtc::VideoFrame& frame) {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   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_);
   if (CheckException(jni)) {
     ALOGE << "Exception in encode texture.";
-    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    ProcessHWError(true /* reset_if_fallback_unavailable */);
     return false;
   }
   return encode_status;
 }
 
-int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread(
+int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
     webrtc::EncodedImageCallback* callback) {
-  RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   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());
+int32_t MediaCodecVideoEncoder::Release() {
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
-  ALOGD << "EncoderReleaseOnCodecThread: Frames received: " <<
-      frames_received_ << ". Encoded: " << frames_encoded_ <<
-      ". Dropped: " << frames_dropped_media_encoder_;
+  ALOGD << "EncoderRelease: 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_);
   if (CheckException(jni)) {
     ALOGE << "Exception in release.";
-    ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
+    ProcessHWError(false /* reset_if_fallback_unavailable */);
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
-  rtc::MessageQueueManager::Clear(this);
-  inited_ = false;
+  {
+#if RTC_DCHECK_IS_ON
+    rtc::CritScope lock(&inited_crit_);
+#endif
+    inited_ = false;
+  }
   use_surface_ = false;
-  ALOGD << "EncoderReleaseOnCodecThread done.";
+  encode_task_.reset(nullptr);
+  weak_factory_.reset(nullptr);
+  ALOGD << "EncoderRelease 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());
+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_)
     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) {
+  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;
   }
   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_);
+  bool ret =
+      jni->CallBooleanMethod(*j_media_codec_video_encoder_, j_set_rates_method_,
+                             last_set_bitrate_kbps_, last_set_fps_);
   if (CheckException(jni) || !ret) {
-    ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+    ProcessHWError(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 12 matching lines @@
 }
 
 jlong MediaCodecVideoEncoder::GetOutputBufferInfoPresentationTimestampUs(
     JNIEnv* jni,
     jobject j_output_buffer_info) {
   return GetLongField(
       jni, j_output_buffer_info, j_info_presentation_timestamp_us_field_);
 }
 
 bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
-  RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
 
   while (true) {
     jobject j_output_buffer_info = jni->CallObjectMethod(
         *j_media_codec_video_encoder_, j_dequeue_output_buffer_method_);
     if (CheckException(jni)) {
       ALOGE << "Exception in set dequeue output buffer.";
-      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+      ProcessHWError(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) {
-      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+      ProcessHWError(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));
     if (CheckException(jni)) {
       ALOGE << "Exception in get direct buffer address.";
-      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+      ProcessHWError(true /* reset_if_fallback_unavailable */);
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     // Callback - return encoded frame.
     const VideoCodecType codec_type =
         webrtc::PayloadNameToCodecType(codec_.name)
             .value_or(webrtc::kVideoCodecUnknown);
     webrtc::EncodedImageCallback::Result callback_result(
         webrtc::EncodedImageCallback::Result::OK);
     if (callback_) {
@@ skipping 68 matching lines @@
           image->qp_ = qp;
         }
         // For H.264 search for start codes.
         const std::vector<webrtc::H264::NaluIndex> nalu_idxs =
             webrtc::H264::FindNaluIndices(payload, payload_size);
         if (nalu_idxs.empty()) {
           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];
-          ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+          ProcessHWError(true /* reset_if_fallback_unavailable */);
           return false;
         }
         header.VerifyAndAllocateFragmentationHeader(nalu_idxs.size());
         for (size_t i = 0; i < nalu_idxs.size(); i++) {
           header.fragmentationOffset[i] = nalu_idxs[i].payload_start_offset;
           header.fragmentationLength[i] = nalu_idxs[i].payload_size;
           header.fragmentationPlType[i] = 0;
           header.fragmentationTimeDiff[i] = 0;
         }
       }
 
       callback_result = callback_->OnEncodedImage(*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);
     if (CheckException(jni) || !success) {
-      ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
+      ProcessHWError(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 169 matching lines @@
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni