talk/app/webrtc/java/jni/androidmediaencoder_jni.cc - Issue 1396073003: Prepare MediaCodecVideoEncoder for surface textures.

Unified Diff: talk/app/webrtc/java/jni/androidmediaencoder_jni.cc

Issue 1396073003: Prepare MediaCodecVideoEncoder for surface textures. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: Self review Created 5 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« talk/app/webrtc/androidtests/src/org/webrtc/MediaCodecVideoEncoderTest.java ('K') | « talk/app/webrtc/androidtests/src/org/webrtc/MediaCodecVideoEncoderTest.java ('k') | talk/app/webrtc/java/src/org/webrtc/MediaCodecVideoEncoder.java » ('j') | talk/app/webrtc/java/src/org/webrtc/MediaCodecVideoEncoder.java » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: talk/app/webrtc/java/jni/androidmediaencoder_jni.cc

diff --git a/talk/app/webrtc/java/jni/androidmediaencoder_jni.cc b/talk/app/webrtc/java/jni/androidmediaencoder_jni.cc

index 76a675d97643af2408cf665dca4b238ed0a631a6..0e2f079429726a19bd72592b9b19d72b86563009 100644

--- a/talk/app/webrtc/java/jni/androidmediaencoder_jni.cc

+++ b/talk/app/webrtc/java/jni/androidmediaencoder_jni.cc

@@ -33,6 +33,7 @@

#include "webrtc/base/checks.h"

#include "webrtc/base/logging.h"

#include "webrtc/base/thread.h"

+#include "webrtc/base/thread_checker.h"

#include "webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.h"

#include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"

#include "webrtc/modules/video_coding/utility/include/quality_scaler.h"

@@ -79,7 +80,8 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder,

public rtc::MessageHandler {

public:

virtual ~MediaCodecVideoEncoder();

- explicit MediaCodecVideoEncoder(JNIEnv* jni, VideoCodecType codecType);

+ MediaCodecVideoEncoder(JNIEnv* jni,

+ VideoCodecType codecType);

// webrtc::VideoEncoder implementation. Everything trampolines to

// |codec_thread_| for execution.

@@ -105,12 +107,10 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder,

int GetTargetFramerate() override;

private:

- // CHECK-fail if not running on |codec_thread_|.

- void CheckOnCodecThread();

- // Release() and InitEncode() in an attempt to restore the codec to an

- // operable state. Necessary after all manner of OMX-layer errors.

- void ResetCodec();

+ // ReleaseOnCodecThread() and InitEncodeOnCodecThread() in an attempt to

magjed_webrtc 2015/10/12 08:22:53 I was confused the first time I read this sentence

perkj_webrtc 2015/10/12 09:16:05 Done.

+ // restore the codec to an operable state. Necessary after all manner of

+ // OMX-layer errors.

+ void ResetCodecOnCodecThread();

// Implementation of webrtc::VideoEncoder methods above, all running on the

// codec thread exclusively.

@@ -119,9 +119,16 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder,

// 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);

+ // Reconfigure to match |frame| in width, height. Also reconfigures the

+ // encoder if |frame| is a texture/byte buffer and the encoder is initialized

magjed_webrtc 2015/10/12 08:22:53 Remove comment about textures :)

perkj_webrtc 2015/10/12 09:16:05 Done.

+ // for byte buffer/texture. Returns false if reconfiguring fails.

+ bool MaybeReconfigureEncoderOnCodecThread(const webrtc::VideoFrame& frame);

magjed_webrtc 2015/10/12 08:22:53 nit: From just reading bool MaybeReconfigureEncode

perkj_webrtc 2015/10/12 09:16:05 Acknowledged.

int32_t EncodeOnCodecThread(

const webrtc::VideoFrame& input_image,

const std::vector<webrtc::VideoFrameType>* frame_types);

+ bool EncodeByteBufferOnCodecThread(JNIEnv* jni,

+ bool key_frame, const webrtc::VideoFrame& frame);

int32_t RegisterEncodeCompleteCallbackOnCodecThread(

webrtc::EncodedImageCallback* callback);

int32_t ReleaseOnCodecThread();

@@ -151,11 +158,13 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder,

// 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.

+ rtc::ThreadChecker codec_thread_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_method_;

+ jmethodID j_encode_buffer_method_;

jmethodID j_release_method_;

jmethodID j_set_rates_method_;

jmethodID j_dequeue_output_buffer_method_;

@@ -214,7 +223,7 @@ MediaCodecVideoEncoder::~MediaCodecVideoEncoder() {

}

MediaCodecVideoEncoder::MediaCodecVideoEncoder(

- JNIEnv* jni, VideoCodecType codecType) :

+JNIEnv* jni, VideoCodecType codecType) :

magjed_webrtc 2015/10/12 08:22:53 Revert this ws change

perkj_webrtc 2015/10/12 09:16:05 Done.

codecType_(codecType),

callback_(NULL),

inited_(false),

@@ -240,19 +249,23 @@ MediaCodecVideoEncoder::MediaCodecVideoEncoder(

// thread.

codec_thread_->SetName("MediaCodecVideoEncoder", NULL);

RTC_CHECK(codec_thread_->Start()) << "Failed to start MediaCodecVideoEncoder";

+ codec_thread_checker_.DetachFromThread();

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;IIII)"

- "[Ljava/nio/ByteBuffer;");

+ "(Lorg/webrtc/MediaCodecVideoEncoder$VideoCodecType;IIII)Z");

+ j_get_input_buffers_method_ = GetMethodID(

+ jni,

+ *j_media_codec_video_encoder_class_,

+ "getInputBuffers",

+ "()[Ljava/nio/ByteBuffer;");

j_dequeue_input_buffer_method_ = GetMethodID(

jni, *j_media_codec_video_encoder_class_, "dequeueInputBuffer", "()I");

- j_encode_method_ = GetMethodID(

- jni, *j_media_codec_video_encoder_class_, "encode", "(ZIIJ)Z");

+ j_encode_buffer_method_ = GetMethodID(

+ jni, *j_media_codec_video_encoder_class_, "encodeBuffer", "(ZIIJ)Z");

j_release_method_ =

GetMethodID(jni, *j_media_codec_video_encoder_class_, "release", "()V");

j_set_rates_method_ = GetMethodID(

@@ -375,6 +388,7 @@ int32_t MediaCodecVideoEncoder::SetRates(uint32_t new_bit_rate,

}

void MediaCodecVideoEncoder::OnMessage(rtc::Message* msg) {

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

JNIEnv* jni = AttachCurrentThreadIfNeeded();

ScopedLocalRefFrame local_ref_frame(jni);

@@ -382,7 +396,6 @@ void MediaCodecVideoEncoder::OnMessage(rtc::Message* msg) {

// functor), so expect no ID/data.

RTC_CHECK(!msg->message_id) << "Unexpected message!";

RTC_CHECK(!msg->pdata) << "Unexpected message!";

- CheckOnCodecThread();

if (!inited_) {

return;

}

@@ -394,17 +407,12 @@ void MediaCodecVideoEncoder::OnMessage(rtc::Message* msg) {

codec_thread_->PostDelayed(kMediaCodecPollMs, this);

}

-void MediaCodecVideoEncoder::CheckOnCodecThread() {

- RTC_CHECK(codec_thread_ == ThreadManager::Instance()->CurrentThread())

- << "Running on wrong thread!";

-void MediaCodecVideoEncoder::ResetCodec() {

- ALOGE << "ResetCodec";

- if (Release() != WEBRTC_VIDEO_CODEC_OK ||

- codec_thread_->Invoke<int32_t>(Bind(

- &MediaCodecVideoEncoder::InitEncodeOnCodecThread, this,

- width_, height_, 0, 0)) != WEBRTC_VIDEO_CODEC_OK) {

+void MediaCodecVideoEncoder::ResetCodecOnCodecThread() {

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

+ ALOGE << "ResetOnCodecThread";

+ if (ReleaseOnCodecThread() != WEBRTC_VIDEO_CODEC_OK ||

+ InitEncodeOnCodecThread(width_, height_, 0, 0)

+ != 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

@@ -413,7 +421,7 @@ void MediaCodecVideoEncoder::ResetCodec() {

int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(

int width, int height, int kbps, int fps) {

- CheckOnCodecThread();

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

JNIEnv* jni = AttachCurrentThreadIfNeeded();

ScopedLocalRefFrame local_ref_frame(jni);

@@ -450,40 +458,44 @@ int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(

frame_rtc_times_ms_.clear();

drop_next_input_frame_ = false;

picture_id_ = static_cast<uint16_t>(rand()) & 0x7FFF;

// We enforce no extra stride/padding in the format creation step.

jobject j_video_codec_enum = JavaEnumFromIndex(

jni, "MediaCodecVideoEncoder$VideoCodecType", codecType_);

+ bool encode_status = jni->CallBooleanMethod(

magjed_webrtc 2015/10/12 08:22:53 const bool

perkj_webrtc 2015/10/12 09:16:05 Done.

+ *j_media_codec_video_encoder_, j_init_encode_method_,

+ j_video_codec_enum, width, height, kbps, fps);

+ if (!encode_status) {

+ ALOGE << "Failed to configure encoder.";

+ return WEBRTC_VIDEO_CODEC_ERROR;

+ }

+ CHECK_EXCEPTION(jni);

jobjectArray input_buffers = reinterpret_cast<jobjectArray>(

jni->CallObjectMethod(*j_media_codec_video_encoder_,

- j_init_encode_method_,

- j_video_codec_enum,

- width_,

- height_,

- kbps,

- fps));

+ j_get_input_buffers_method_));

CHECK_EXCEPTION(jni);

if (IsNull(jni, input_buffers)) {

return WEBRTC_VIDEO_CODEC_ERROR;

}

- inited_ = true;

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.";

- return WEBRTC_VIDEO_CODEC_ERROR;

+ case COLOR_FormatYUV420Planar:

magjed_webrtc 2015/10/12 08:22:53 Revert indentation change, it was correct before?

perkj_webrtc 2015/10/12 09:16:06 Done.

+ 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.";

+ return WEBRTC_VIDEO_CODEC_ERROR;

}

size_t num_input_buffers = jni->GetArrayLength(input_buffers);

RTC_CHECK(input_buffers_.empty())

- << "Unexpected double InitEncode without Release";

+ << "Unexpected double InitEncode without Release";

magjed_webrtc 2015/10/12 08:22:53 ditto: Revert ws change

perkj_webrtc 2015/10/12 09:16:05 Done.

input_buffers_.resize(num_input_buffers);

for (size_t i = 0; i < num_input_buffers; ++i) {

input_buffers_[i] =

@@ -495,6 +507,8 @@ int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(

}

CHECK_EXCEPTION(jni);

+ inited_ = true;

codec_thread_->PostDelayed(kMediaCodecPollMs, this);

return WEBRTC_VIDEO_CODEC_OK;

}

@@ -502,21 +516,22 @@ int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(

int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(

const webrtc::VideoFrame& frame,

const std::vector<webrtc::VideoFrameType>* frame_types) {

- CheckOnCodecThread();

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

JNIEnv* jni = AttachCurrentThreadIfNeeded();

ScopedLocalRefFrame local_ref_frame(jni);

if (!inited_) {

return WEBRTC_VIDEO_CODEC_UNINITIALIZED;

}

frames_received_++;

if (!DeliverPendingOutputs(jni)) {

- ResetCodec();

+ ResetCodecOnCodecThread();

// Continue as if everything's fine.

}

if (drop_next_input_frame_) {

- ALOGV("Encoder drop frame - failed callback.");

+ ALOGD << "Encoder drop frame - failed callback.";

drop_next_input_frame_ = false;

return WEBRTC_VIDEO_CODEC_OK;

}

@@ -529,13 +544,9 @@ int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(

const VideoFrame& input_frame =

scale_ ? quality_scaler_.GetScaledFrame(frame) : frame;

- if (input_frame.width() != width_ || input_frame.height() != height_) {

- ALOGD << "Frame resolution change from " << width_ << " x " << height_ <<

- " to " << input_frame.width() << " x " << input_frame.height();

- width_ = input_frame.width();

- height_ = input_frame.height();

- ResetCodec();

- return WEBRTC_VIDEO_CODEC_OK;

+ if (!MaybeReconfigureEncoderOnCodecThread(frame)) {

+ ALOGE << "Failed to reconfigure encoder.";

+ return WEBRTC_VIDEO_CODEC_ERROR;

}

// Check if we accumulated too many frames in encoder input buffers

@@ -553,20 +564,70 @@ int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(

}

+ last_input_timestamp_ms_ =

+ current_timestamp_us_ / rtc::kNumMicrosecsPerMillisec;

+ frames_in_queue_++;

+ // Save input image timestamps for later output

+ timestamps_.push_back(input_frame.timestamp());

+ render_times_ms_.push_back(input_frame.render_time_ms());

+ frame_rtc_times_ms_.push_back(GetCurrentTimeMs());

+ bool key_frame = frame_types->front() != webrtc::kDeltaFrame;

magjed_webrtc 2015/10/12 08:22:53 const bool

perkj_webrtc 2015/10/12 09:16:05 Done.

+ bool encode_status = true;

magjed_webrtc 2015/10/12 08:22:53 const bool encode_status = EncodeByteBufferOnCodec

perkj_webrtc 2015/10/12 09:16:05 Done.

+ encode_status = EncodeByteBufferOnCodecThread(jni, key_frame, input_frame);

+ current_timestamp_us_ += 1000000 / last_set_fps_;

+ if (!encode_status || !DeliverPendingOutputs(jni)) {

+ ALOGE << "Failed deliver pending outputs.";

+ ResetCodecOnCodecThread();

+ return WEBRTC_VIDEO_CODEC_ERROR;

+ }

+ return WEBRTC_VIDEO_CODEC_OK;

+bool MediaCodecVideoEncoder::MaybeReconfigureEncoderOnCodecThread(

+ const webrtc::VideoFrame& frame) {

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

+ bool reconfigure_due_to_size =

magjed_webrtc 2015/10/12 08:22:53 const bool

perkj_webrtc 2015/10/12 09:16:05 Done.

+ frame.width() != width_ || frame.height() != height_;

+ if (reconfigure_due_to_size) {

+ ALOGD << "Reconfigure encoder due to frame resolution change from "

+ << width_ << " x " << height_ << " to " << frame.width() << " x "

+ << frame.height();

+ width_ = frame.width();

+ height_ = frame.height();

+ }

+ if (!reconfigure_due_to_size)

+ return true;

+ ReleaseOnCodecThread();

+ return InitEncodeOnCodecThread(width_, height_, 0, 0) ==

+ WEBRTC_VIDEO_CODEC_OK;

+bool MediaCodecVideoEncoder::EncodeByteBufferOnCodecThread(JNIEnv* jni,

+ bool key_frame, const webrtc::VideoFrame& frame) {

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

int j_input_buffer_index = jni->CallIntMethod(*j_media_codec_video_encoder_,

j_dequeue_input_buffer_method_);

CHECK_EXCEPTION(jni);

if (j_input_buffer_index == -1) {

// Video codec falls behind - no input buffer available.

- ALOGV("Encoder drop frame - no input buffers available");

+ ALOGD <<"Encoder drop frame - no input buffers available";

frames_dropped_++;

// Report dropped frame to quality_scaler_.

OnDroppedFrame();

- return WEBRTC_VIDEO_CODEC_OK; // TODO(fischman): see webrtc bug 2887.

+ return true; // TODO(fischman): see webrtc bug 2887.

}

if (j_input_buffer_index == -2) {

- ResetCodec();

- return WEBRTC_VIDEO_CODEC_ERROR;

+ return false;

}

ALOGV("Encoder frame in # %d. TS: %lld. Q: %d",

@@ -578,40 +639,26 @@ int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(

CHECK_EXCEPTION(jni);

RTC_CHECK(yuv_buffer) << "Indirect buffer??";

RTC_CHECK(!libyuv::ConvertFromI420(

- input_frame.buffer(webrtc::kYPlane), input_frame.stride(webrtc::kYPlane),

- input_frame.buffer(webrtc::kUPlane), input_frame.stride(webrtc::kUPlane),

- input_frame.buffer(webrtc::kVPlane), input_frame.stride(webrtc::kVPlane),

+ frame.buffer(webrtc::kYPlane), frame.stride(webrtc::kYPlane),

+ frame.buffer(webrtc::kUPlane), frame.stride(webrtc::kUPlane),

+ frame.buffer(webrtc::kVPlane), frame.stride(webrtc::kVPlane),

yuv_buffer, width_, width_, height_, encoder_fourcc_))

<< "ConvertFromI420 failed";

- last_input_timestamp_ms_ = current_timestamp_us_ / 1000;

- frames_in_queue_++;

- // Save input image timestamps for later output

- timestamps_.push_back(input_frame.timestamp());

- render_times_ms_.push_back(input_frame.render_time_ms());

- frame_rtc_times_ms_.push_back(GetCurrentTimeMs());

- bool key_frame = frame_types->front() != webrtc::kDeltaFrame;

bool encode_status = jni->CallBooleanMethod(*j_media_codec_video_encoder_,

- j_encode_method_,

+ j_encode_buffer_method_,

key_frame,

j_input_buffer_index,

yuv_size_,

current_timestamp_us_);

CHECK_EXCEPTION(jni);

- current_timestamp_us_ += 1000000 / last_set_fps_;

- if (!encode_status || !DeliverPendingOutputs(jni)) {

- ResetCodec();

- return WEBRTC_VIDEO_CODEC_ERROR;

- }

- return WEBRTC_VIDEO_CODEC_OK;

+ return encode_status;

}

int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread(

webrtc::EncodedImageCallback* callback) {

- CheckOnCodecThread();

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

JNIEnv* jni = AttachCurrentThreadIfNeeded();

ScopedLocalRefFrame local_ref_frame(jni);

callback_ = callback;

@@ -619,10 +666,10 @@ int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread(

}

int32_t MediaCodecVideoEncoder::ReleaseOnCodecThread() {

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

if (!inited_) {

return WEBRTC_VIDEO_CODEC_OK;

}

- CheckOnCodecThread();

JNIEnv* jni = AttachCurrentThreadIfNeeded();

ALOGD << "EncoderReleaseOnCodecThread: Frames received: " <<

frames_received_ << ". Encoded: " << frames_encoded_ <<

@@ -641,7 +688,7 @@ int32_t MediaCodecVideoEncoder::ReleaseOnCodecThread() {

int32_t MediaCodecVideoEncoder::SetRatesOnCodecThread(uint32_t new_bit_rate,

uint32_t frame_rate) {

- CheckOnCodecThread();

+ RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());

if (last_set_bitrate_kbps_ == new_bit_rate &&

last_set_fps_ == frame_rate) {

return WEBRTC_VIDEO_CODEC_OK;

@@ -660,7 +707,7 @@ int32_t MediaCodecVideoEncoder::SetRatesOnCodecThread(uint32_t new_bit_rate,

last_set_fps_);

CHECK_EXCEPTION(jni);

if (!ret) {

- ResetCodec();

+ ResetCodecOnCodecThread();

return WEBRTC_VIDEO_CODEC_ERROR;

}

return WEBRTC_VIDEO_CODEC_OK;

@@ -692,6 +739,7 @@ jlong MediaCodecVideoEncoder::GetOutputBufferInfoPresentationTimestampUs(

}

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_);

@@ -703,7 +751,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {

int output_buffer_index =

GetOutputBufferInfoIndex(jni, j_output_buffer_info);

if (output_buffer_index == -1) {

- ResetCodec();

+ ResetCodecOnCodecThread();

return false;

}

@@ -824,7 +872,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {

ALOGE << "Data:" << image->_buffer[0] << " " << image->_buffer[1]

<< " " << image->_buffer[2] << " " << image->_buffer[3]

<< " " << image->_buffer[4] << " " << image->_buffer[5];

- ResetCodec();

+ ResetCodecOnCodecThread();

return false;

}

scPositions[scPositionsLength] = payload_size;

@@ -847,7 +895,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {

output_buffer_index);

CHECK_EXCEPTION(jni);

if (!success) {

- ResetCodec();

+ ResetCodecOnCodecThread();

return false;

}