media/jni/android_media_MediaCodec.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright 2012, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 //#define LOG_NDEBUG 0
 #define LOG_TAG "MediaCodec-JNI"
 #include <utils/Log.h>

 #include "android_media_MediaCodec.h"

 #include "android_media_Utils.h"
 #include "android_runtime/AndroidRuntime.h"
 #include "android_runtime/android_view_Surface.h"
 #include "jni.h"
 #include "JNIHelp.h"

 #include <gui/Surface.h>
 #include <gui/SurfaceTextureClient.h>

 #include <media/stagefright/MediaCodec.h>
 #include <media/stagefright/foundation/ABuffer.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/ALooper.h>
 #include <media/stagefright/foundation/AMessage.h>
 #include <media/stagefright/MediaErrors.h>

 namespace android {

 // Keep these in sync with their equivalents in MediaCodec.java !!!
 enum {
     DEQUEUE_INFO_TRY_AGAIN_LATER            = -1,
     DEQUEUE_INFO_OUTPUT_FORMAT_CHANGED      = -2,
     DEQUEUE_INFO_OUTPUT_BUFFERS_CHANGED     = -3,
 };

 struct fields_t {
     jfieldID context;
 };

 static fields_t gFields;

 ////////////////////////////////////////////////////////////////////////////////

 JMediaCodec::JMediaCodec(
         JNIEnv *env, jobject thiz,
         const char *name, bool nameIsType, bool encoder)
     : mClass(NULL),
       mObject(NULL) {
     jclass clazz = env->GetObjectClass(thiz);
     CHECK(clazz != NULL);

     mClass = (jclass)env->NewGlobalRef(clazz);
     mObject = env->NewWeakGlobalRef(thiz);

     mLooper = new ALooper;
     mLooper->setName("MediaCodec_looper");

     mLooper->start(
             false,      // runOnCallingThread
             false,       // canCallJava
             PRIORITY_DEFAULT);

     if (nameIsType) {
         mCodec = MediaCodec::CreateByType(mLooper, name, encoder);
     } else {
         mCodec = MediaCodec::CreateByComponentName(mLooper, name);
     }
 }

 status_t JMediaCodec::initCheck() const {
     return mCodec != NULL ? OK : NO_INIT;
 }

 JMediaCodec::~JMediaCodec() {
     mCodec->release();

     JNIEnv *env = AndroidRuntime::getJNIEnv();

     env->DeleteWeakGlobalRef(mObject);
     mObject = NULL;
     env->DeleteGlobalRef(mClass);
     mClass = NULL;
 }

 status_t JMediaCodec::configure(
         const sp<AMessage> &format,
         const sp<ISurfaceTexture> &surfaceTexture,
         int flags) {
     sp<SurfaceTextureClient> client;
     if (surfaceTexture != NULL) {
         client = new SurfaceTextureClient(surfaceTexture);
     }
     return mCodec->configure(format, client, flags);
 }

 status_t JMediaCodec::start() {
     return mCodec->start();
 }

 status_t JMediaCodec::stop() {
     return mCodec->stop();
 }

 status_t JMediaCodec::flush() {
     return mCodec->flush();
 }

 status_t JMediaCodec::queueInputBuffer(
         size_t index,
         size_t offset, size_t size, int64_t timeUs, uint32_t flags) {
     return mCodec->queueInputBuffer(index, offset, size, timeUs, flags);
 }

 status_t JMediaCodec::dequeueInputBuffer(size_t *index, int64_t timeoutUs) {
     return mCodec->dequeueInputBuffer(index, timeoutUs);
 }

 status_t JMediaCodec::dequeueOutputBuffer(
         JNIEnv *env, jobject bufferInfo, size_t *index, int64_t timeoutUs) {
     size_t size, offset;
     int64_t timeUs;
     uint32_t flags;
     status_t err;
     if ((err = mCodec->dequeueOutputBuffer(
                     index, &offset, &size, &timeUs, &flags, timeoutUs)) != OK) {
         return err;
     }

     jclass clazz = env->FindClass("android/media/MediaCodec$BufferInfo");

     jmethodID method = env->GetMethodID(clazz, "set", "(IIJI)V");
     env->CallVoidMethod(bufferInfo, method, offset, size, timeUs, flags);

     return OK;
 }

 status_t JMediaCodec::releaseOutputBuffer(size_t index, bool render) {
     return render
         ? mCodec->renderOutputBufferAndRelease(index)
         : mCodec->releaseOutputBuffer(index);
 }

 status_t JMediaCodec::getOutputFormat(JNIEnv *env, jobject *format) const {
     sp<AMessage> msg;
     status_t err;
     if ((err = mCodec->getOutputFormat(&msg)) != OK) {
         return err;
     }

     return ConvertMessageToMap(env, msg, format);
 }

 status_t JMediaCodec::getBuffers(
         JNIEnv *env, bool input, jobjectArray *bufArray) const {
     Vector<sp<ABuffer> > buffers;

     status_t err =
         input
             ? mCodec->getInputBuffers(&buffers)
             : mCodec->getOutputBuffers(&buffers);

     if (err != OK) {
         return err;
     }

     jclass byteBufferClass = env->FindClass("java/nio/ByteBuffer");

     *bufArray = (jobjectArray)env->NewObjectArray(
             buffers.size(), byteBufferClass, NULL);

     for (size_t i = 0; i < buffers.size(); ++i) {
         const sp<ABuffer> &buffer = buffers.itemAt(i);

         jobject byteBuffer =
             env->NewDirectByteBuffer(
                 buffer->base(),
                 buffer->capacity());

         env->SetObjectArrayElement(
                 *bufArray, i, byteBuffer);

         env->DeleteLocalRef(byteBuffer);
         byteBuffer = NULL;
     }

     return OK;
 }

 }  // namespace android

 ////////////////////////////////////////////////////////////////////////////////

 using namespace android;

 static sp<JMediaCodec> setMediaCodec(
         JNIEnv *env, jobject thiz, const sp<JMediaCodec> &codec) {
     sp<JMediaCodec> old = (JMediaCodec *)env->GetIntField(thiz, gFields.context);
     if (codec != NULL) {
         codec->incStrong(thiz);
     }
     if (old != NULL) {
         old->decStrong(thiz);
     }
     env->SetIntField(thiz, gFields.context, (int)codec.get());

     return old;
 }

 static sp<JMediaCodec> getMediaCodec(JNIEnv *env, jobject thiz) {
     return (JMediaCodec *)env->GetIntField(thiz, gFields.context);
 }

 static void android_media_MediaCodec_release(JNIEnv *env, jobject thiz) {
     setMediaCodec(env, thiz, NULL);
 }

 static jint throwExceptionAsNecessary(JNIEnv *env, status_t err) {
     switch (err) {
         case OK:
             return 0;

         case -EAGAIN:
             return DEQUEUE_INFO_TRY_AGAIN_LATER;

         case INFO_FORMAT_CHANGED:
             return DEQUEUE_INFO_OUTPUT_FORMAT_CHANGED;

         case INFO_OUTPUT_BUFFERS_CHANGED:
             return DEQUEUE_INFO_OUTPUT_BUFFERS_CHANGED;

         default:
         {
             jniThrowException(env, "java/lang/IllegalStateException", NULL);
             break;
         }
     }

     return 0;
 }

 static void android_media_MediaCodec_native_configure(
         JNIEnv *env,
         jobject thiz,
         jobjectArray keys, jobjectArray values,
         jobject jsurface,
         jint flags) {
     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return;
     }

     sp<AMessage> format;
     status_t err = ConvertKeyValueArraysToMessage(env, keys, values, &format);

     if (err != OK) {
         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
         return;
     }

     sp<ISurfaceTexture> surfaceTexture;
     if (jsurface != NULL) {
         sp<Surface> surface(Surface_getSurface(env, jsurface));
         if (surface != NULL) {
             surfaceTexture = surface->getSurfaceTexture();
         } else {
             jniThrowException(
                     env,
                     "java/lang/IllegalArgumentException",
                     "The surface has been released");
             return;
         }
     }

     err = codec->configure(format, surfaceTexture, flags);

     throwExceptionAsNecessary(env, err);
 }

 static void android_media_MediaCodec_start(JNIEnv *env, jobject thiz) {
     ALOGV("android_media_MediaCodec_start");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return;
     }

     status_t err = codec->start();

     throwExceptionAsNecessary(env, err);
 }

 static void android_media_MediaCodec_stop(JNIEnv *env, jobject thiz) {
     ALOGV("android_media_MediaCodec_stop");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return;
     }

     status_t err = codec->stop();

     throwExceptionAsNecessary(env, err);
 }

 static void android_media_MediaCodec_flush(JNIEnv *env, jobject thiz) {
     ALOGV("android_media_MediaCodec_flush");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return;
     }

     status_t err = codec->flush();

     throwExceptionAsNecessary(env, err);
 }

 static void android_media_MediaCodec_queueInputBuffer(
         JNIEnv *env,
         jobject thiz,
         jint index,
         jint offset,
         jint size,
         jlong timestampUs,
         jint flags) {
     ALOGV("android_media_MediaCodec_queueInputBuffer");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return;
     }

     status_t err = codec->queueInputBuffer(
             index, offset, size, timestampUs, flags);

     throwExceptionAsNecessary(env, err);
 }

 static jint android_media_MediaCodec_dequeueInputBuffer(
         JNIEnv *env, jobject thiz, jlong timeoutUs) {
     ALOGV("android_media_MediaCodec_dequeueInputBuffer");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return -1;
     }

     size_t index;
     status_t err = codec->dequeueInputBuffer(&index, timeoutUs);

     if (err == OK) {
         return index;
     }

     return throwExceptionAsNecessary(env, err);
 }

 static jint android_media_MediaCodec_dequeueOutputBuffer(
         JNIEnv *env, jobject thiz, jobject bufferInfo, jlong timeoutUs) {
     ALOGV("android_media_MediaCodec_dequeueOutputBuffer");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return NULL;
     }

     size_t index;
     status_t err = codec->dequeueOutputBuffer(
             env, bufferInfo, &index, timeoutUs);

     if (err == OK) {
         return index;
     }

     return throwExceptionAsNecessary(env, err);
 }

 static void android_media_MediaCodec_releaseOutputBuffer(
         JNIEnv *env, jobject thiz, jint index, jboolean render) {
     ALOGV("android_media_MediaCodec_renderOutputBufferAndRelease");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return;
     }

     status_t err = codec->releaseOutputBuffer(index, render);

     throwExceptionAsNecessary(env, err);
 }

 static jobject android_media_MediaCodec_getOutputFormat(
         JNIEnv *env, jobject thiz) {
     ALOGV("android_media_MediaCodec_getOutputFormat");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return NULL;
     }

     jobject format;
     status_t err = codec->getOutputFormat(env, &format);

     if (err == OK) {
         return format;
     }

     throwExceptionAsNecessary(env, err);

     return NULL;
 }

 static jobjectArray android_media_MediaCodec_getBuffers(
         JNIEnv *env, jobject thiz, jboolean input) {
     ALOGV("android_media_MediaCodec_getBuffers");

     sp<JMediaCodec> codec = getMediaCodec(env, thiz);

     if (codec == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException", NULL);
         return NULL;
     }

     jobjectArray buffers;
     status_t err = codec->getBuffers(env, input, &buffers);

     if (err == OK) {
         return buffers;
     }

     throwExceptionAsNecessary(env, err);

     return NULL;
 }

 static void android_media_MediaCodec_native_init(JNIEnv *env) {
     jclass clazz = env->FindClass("android/media/MediaCodec");
     CHECK(clazz != NULL);

     gFields.context = env->GetFieldID(clazz, "mNativeContext", "I");
     CHECK(gFields.context != NULL);
 }

 static void android_media_MediaCodec_native_setup(
         JNIEnv *env, jobject thiz,
         jstring name, jboolean nameIsType, jboolean encoder) {
     if (name == NULL) {
         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
         return;
     }

     const char *tmp = env->GetStringUTFChars(name, NULL);

     if (tmp == NULL) {
         return;
     }

     sp<JMediaCodec> codec = new JMediaCodec(env, thiz, tmp, nameIsType, encoder);

     status_t err = codec->initCheck();

     env->ReleaseStringUTFChars(name, tmp);
     tmp = NULL;

     if (err != OK) {
         jniThrowException(
                 env,
                 "java/io/IOException",
                 "Failed to allocate component instance");
         return;
     }

     setMediaCodec(env,thiz, codec);
 }

 static void android_media_MediaCodec_native_finalize(
         JNIEnv *env, jobject thiz) {
     android_media_MediaCodec_release(env, thiz);
 }

 static JNINativeMethod gMethods[] = {
     { "release", "()V", (void *)android_media_MediaCodec_release },

     { "native_configure",
       "([Ljava/lang/String;[Ljava/lang/Object;Landroid/view/Surface;I)V",
       (void *)android_media_MediaCodec_native_configure },

     { "start", "()V", (void *)android_media_MediaCodec_start },
     { "stop", "()V", (void *)android_media_MediaCodec_stop },
     { "flush", "()V", (void *)android_media_MediaCodec_flush },

     { "queueInputBuffer", "(IIIJI)V",
       (void *)android_media_MediaCodec_queueInputBuffer },

     { "dequeueInputBuffer", "(J)I",
       (void *)android_media_MediaCodec_dequeueInputBuffer },

     { "dequeueOutputBuffer", "(Landroid/media/MediaCodec$BufferInfo;J)I",
       (void *)android_media_MediaCodec_dequeueOutputBuffer },

     { "releaseOutputBuffer", "(IZ)V",
       (void *)android_media_MediaCodec_releaseOutputBuffer },

     { "getOutputFormat", "()Ljava/util/Map;",
       (void *)android_media_MediaCodec_getOutputFormat },

     { "getBuffers", "(Z)[Ljava/nio/ByteBuffer;",
       (void *)android_media_MediaCodec_getBuffers },

     { "native_init", "()V", (void *)android_media_MediaCodec_native_init },

     { "native_setup", "(Ljava/lang/String;ZZ)V",
       (void *)android_media_MediaCodec_native_setup },

     { "native_finalize", "()V",
       (void *)android_media_MediaCodec_native_finalize },
 };

 int register_android_media_MediaCodec(JNIEnv *env) {
     return AndroidRuntime::registerNativeMethods(env,
                 "android/media/MediaCodec", gMethods, NELEM(gMethods));
 }
	/*
	* Copyright 2012, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	//#define LOG_NDEBUG 0
	#define LOG_TAG "MediaCodec-JNI"
	#include <utils/Log.h>

	#include "android_media_MediaCodec.h"

	#include "android_media_Utils.h"
	#include "android_runtime/AndroidRuntime.h"
	#include "android_runtime/android_view_Surface.h"
	#include "jni.h"
	#include "JNIHelp.h"

	#include <gui/Surface.h>
	#include <gui/SurfaceTextureClient.h>

	#include <media/stagefright/MediaCodec.h>
	#include <media/stagefright/foundation/ABuffer.h>
	#include <media/stagefright/foundation/ADebug.h>
	#include <media/stagefright/foundation/ALooper.h>
	#include <media/stagefright/foundation/AMessage.h>
	#include <media/stagefright/MediaErrors.h>

	namespace android {

	// Keep these in sync with their equivalents in MediaCodec.java !!!
	enum {
	DEQUEUE_INFO_TRY_AGAIN_LATER = -1,
	DEQUEUE_INFO_OUTPUT_FORMAT_CHANGED = -2,
	DEQUEUE_INFO_OUTPUT_BUFFERS_CHANGED = -3,
	};

	struct fields_t {
	jfieldID context;
	};

	static fields_t gFields;

	////////////////////////////////////////////////////////////////////////////////

	JMediaCodec::JMediaCodec(
	JNIEnv *env, jobject thiz,
	const char *name, bool nameIsType, bool encoder)
	: mClass(NULL),
	mObject(NULL) {
	jclass clazz = env->GetObjectClass(thiz);
	CHECK(clazz != NULL);

	mClass = (jclass)env->NewGlobalRef(clazz);
	mObject = env->NewWeakGlobalRef(thiz);

	mLooper = new ALooper;
	mLooper->setName("MediaCodec_looper");

	mLooper->start(
	false, // runOnCallingThread
	false, // canCallJava
	PRIORITY_DEFAULT);

	if (nameIsType) {
	mCodec = MediaCodec::CreateByType(mLooper, name, encoder);
	} else {
	mCodec = MediaCodec::CreateByComponentName(mLooper, name);
	}
	}

	status_t JMediaCodec::initCheck() const {
	return mCodec != NULL ? OK : NO_INIT;
	}

	JMediaCodec::~JMediaCodec() {
	mCodec->release();

	JNIEnv *env = AndroidRuntime::getJNIEnv();

	env->DeleteWeakGlobalRef(mObject);
	mObject = NULL;
	env->DeleteGlobalRef(mClass);
	mClass = NULL;
	}

	status_t JMediaCodec::configure(
	const sp<AMessage> &format,
	const sp<ISurfaceTexture> &surfaceTexture,
	int flags) {
	sp<SurfaceTextureClient> client;
	if (surfaceTexture != NULL) {
	client = new SurfaceTextureClient(surfaceTexture);
	}
	return mCodec->configure(format, client, flags);
	}

	status_t JMediaCodec::start() {
	return mCodec->start();
	}

	status_t JMediaCodec::stop() {
	return mCodec->stop();
	}

	status_t JMediaCodec::flush() {
	return mCodec->flush();
	}

	status_t JMediaCodec::queueInputBuffer(
	size_t index,
	size_t offset, size_t size, int64_t timeUs, uint32_t flags) {
	return mCodec->queueInputBuffer(index, offset, size, timeUs, flags);
	}

	status_t JMediaCodec::dequeueInputBuffer(size_t *index, int64_t timeoutUs) {
	return mCodec->dequeueInputBuffer(index, timeoutUs);
	}

	status_t JMediaCodec::dequeueOutputBuffer(
	JNIEnv env, jobject bufferInfo, size_t index, int64_t timeoutUs) {
	size_t size, offset;
	int64_t timeUs;
	uint32_t flags;
	status_t err;
	if ((err = mCodec->dequeueOutputBuffer(
	index, &offset, &size, &timeUs, &flags, timeoutUs)) != OK) {
	return err;
	}

	jclass clazz = env->FindClass("android/media/MediaCodec$BufferInfo");

	jmethodID method = env->GetMethodID(clazz, "set", "(IIJI)V");
	env->CallVoidMethod(bufferInfo, method, offset, size, timeUs, flags);

	return OK;
	}

	status_t JMediaCodec::releaseOutputBuffer(size_t index, bool render) {
	return render
	? mCodec->renderOutputBufferAndRelease(index)
	: mCodec->releaseOutputBuffer(index);
	}

	status_t JMediaCodec::getOutputFormat(JNIEnv env, jobject format) const {
	sp<AMessage> msg;
	status_t err;
	if ((err = mCodec->getOutputFormat(&msg)) != OK) {
	return err;
	}

	return ConvertMessageToMap(env, msg, format);
	}

	status_t JMediaCodec::getBuffers(
	JNIEnv env, bool input, jobjectArray bufArray) const {
	Vector<sp<ABuffer> > buffers;

	status_t err =
	input
	? mCodec->getInputBuffers(&buffers)
	: mCodec->getOutputBuffers(&buffers);

	if (err != OK) {
	return err;
	}

	jclass byteBufferClass = env->FindClass("java/nio/ByteBuffer");

	*bufArray = (jobjectArray)env->NewObjectArray(
	buffers.size(), byteBufferClass, NULL);

	for (size_t i = 0; i < buffers.size(); ++i) {
	const sp<ABuffer> &buffer = buffers.itemAt(i);

	jobject byteBuffer =
	env->NewDirectByteBuffer(
	buffer->base(),
	buffer->capacity());

	env->SetObjectArrayElement(
	*bufArray, i, byteBuffer);

	env->DeleteLocalRef(byteBuffer);
	byteBuffer = NULL;
	}

	return OK;
	}

	} // namespace android

	////////////////////////////////////////////////////////////////////////////////

	using namespace android;

	static sp<JMediaCodec> setMediaCodec(
	JNIEnv *env, jobject thiz, const sp<JMediaCodec> &codec) {
	sp<JMediaCodec> old = (JMediaCodec *)env->GetIntField(thiz, gFields.context);
	if (codec != NULL) {
	codec->incStrong(thiz);
	}
	if (old != NULL) {
	old->decStrong(thiz);
	}
	env->SetIntField(thiz, gFields.context, (int)codec.get());

	return old;
	}

	static sp<JMediaCodec> getMediaCodec(JNIEnv *env, jobject thiz) {
	return (JMediaCodec *)env->GetIntField(thiz, gFields.context);
	}

	static void android_media_MediaCodec_release(JNIEnv *env, jobject thiz) {
	setMediaCodec(env, thiz, NULL);
	}

	static jint throwExceptionAsNecessary(JNIEnv *env, status_t err) {
	switch (err) {
	case OK:
	return 0;

	case -EAGAIN:
	return DEQUEUE_INFO_TRY_AGAIN_LATER;

	case INFO_FORMAT_CHANGED:
	return DEQUEUE_INFO_OUTPUT_FORMAT_CHANGED;

	case INFO_OUTPUT_BUFFERS_CHANGED:
	return DEQUEUE_INFO_OUTPUT_BUFFERS_CHANGED;

	default:
	{
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	break;
	}
	}

	return 0;
	}

	static void android_media_MediaCodec_native_configure(
	JNIEnv *env,
	jobject thiz,
	jobjectArray keys, jobjectArray values,
	jobject jsurface,
	jint flags) {
	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return;
	}

	sp<AMessage> format;
	status_t err = ConvertKeyValueArraysToMessage(env, keys, values, &format);

	if (err != OK) {
	jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
	return;
	}

	sp<ISurfaceTexture> surfaceTexture;
	if (jsurface != NULL) {
	sp<Surface> surface(Surface_getSurface(env, jsurface));
	if (surface != NULL) {
	surfaceTexture = surface->getSurfaceTexture();
	} else {
	jniThrowException(
	env,
	"java/lang/IllegalArgumentException",
	"The surface has been released");
	return;
	}
	}

	err = codec->configure(format, surfaceTexture, flags);

	throwExceptionAsNecessary(env, err);
	}

	static void android_media_MediaCodec_start(JNIEnv *env, jobject thiz) {
	ALOGV("android_media_MediaCodec_start");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return;
	}

	status_t err = codec->start();

	throwExceptionAsNecessary(env, err);
	}

	static void android_media_MediaCodec_stop(JNIEnv *env, jobject thiz) {
	ALOGV("android_media_MediaCodec_stop");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return;
	}

	status_t err = codec->stop();

	throwExceptionAsNecessary(env, err);
	}

	static void android_media_MediaCodec_flush(JNIEnv *env, jobject thiz) {
	ALOGV("android_media_MediaCodec_flush");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return;
	}

	status_t err = codec->flush();

	throwExceptionAsNecessary(env, err);
	}

	static void android_media_MediaCodec_queueInputBuffer(
	JNIEnv *env,
	jobject thiz,
	jint index,
	jint offset,
	jint size,
	jlong timestampUs,
	jint flags) {
	ALOGV("android_media_MediaCodec_queueInputBuffer");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return;
	}

	status_t err = codec->queueInputBuffer(
	index, offset, size, timestampUs, flags);

	throwExceptionAsNecessary(env, err);
	}

	static jint android_media_MediaCodec_dequeueInputBuffer(
	JNIEnv *env, jobject thiz, jlong timeoutUs) {
	ALOGV("android_media_MediaCodec_dequeueInputBuffer");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return -1;
	}

	size_t index;
	status_t err = codec->dequeueInputBuffer(&index, timeoutUs);

	if (err == OK) {
	return index;
	}

	return throwExceptionAsNecessary(env, err);
	}

	static jint android_media_MediaCodec_dequeueOutputBuffer(
	JNIEnv *env, jobject thiz, jobject bufferInfo, jlong timeoutUs) {
	ALOGV("android_media_MediaCodec_dequeueOutputBuffer");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return NULL;
	}

	size_t index;
	status_t err = codec->dequeueOutputBuffer(
	env, bufferInfo, &index, timeoutUs);

	if (err == OK) {
	return index;
	}

	return throwExceptionAsNecessary(env, err);
	}

	static void android_media_MediaCodec_releaseOutputBuffer(
	JNIEnv *env, jobject thiz, jint index, jboolean render) {
	ALOGV("android_media_MediaCodec_renderOutputBufferAndRelease");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return;
	}

	status_t err = codec->releaseOutputBuffer(index, render);

	throwExceptionAsNecessary(env, err);
	}

	static jobject android_media_MediaCodec_getOutputFormat(
	JNIEnv *env, jobject thiz) {
	ALOGV("android_media_MediaCodec_getOutputFormat");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return NULL;
	}

	jobject format;
	status_t err = codec->getOutputFormat(env, &format);

	if (err == OK) {
	return format;
	}

	throwExceptionAsNecessary(env, err);

	return NULL;
	}

	static jobjectArray android_media_MediaCodec_getBuffers(
	JNIEnv *env, jobject thiz, jboolean input) {
	ALOGV("android_media_MediaCodec_getBuffers");

	sp<JMediaCodec> codec = getMediaCodec(env, thiz);

	if (codec == NULL) {
	jniThrowException(env, "java/lang/IllegalStateException", NULL);
	return NULL;
	}

	jobjectArray buffers;
	status_t err = codec->getBuffers(env, input, &buffers);

	if (err == OK) {
	return buffers;
	}

	throwExceptionAsNecessary(env, err);

	return NULL;
	}

	static void android_media_MediaCodec_native_init(JNIEnv *env) {
	jclass clazz = env->FindClass("android/media/MediaCodec");
	CHECK(clazz != NULL);

	gFields.context = env->GetFieldID(clazz, "mNativeContext", "I");
	CHECK(gFields.context != NULL);
	}

	static void android_media_MediaCodec_native_setup(
	JNIEnv *env, jobject thiz,
	jstring name, jboolean nameIsType, jboolean encoder) {
	if (name == NULL) {
	jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
	return;
	}

	const char *tmp = env->GetStringUTFChars(name, NULL);

	if (tmp == NULL) {
	return;
	}

	sp<JMediaCodec> codec = new JMediaCodec(env, thiz, tmp, nameIsType, encoder);

	status_t err = codec->initCheck();

	env->ReleaseStringUTFChars(name, tmp);
	tmp = NULL;

	if (err != OK) {
	jniThrowException(
	env,
	"java/io/IOException",
	"Failed to allocate component instance");
	return;
	}

	setMediaCodec(env,thiz, codec);
	}

	static void android_media_MediaCodec_native_finalize(
	JNIEnv *env, jobject thiz) {
	android_media_MediaCodec_release(env, thiz);
	}

	static JNINativeMethod gMethods[] = {
	{ "release", "()V", (void *)android_media_MediaCodec_release },

	{ "native_configure",
	"([Ljava/lang/String;[Ljava/lang/Object;Landroid/view/Surface;I)V",
	(void *)android_media_MediaCodec_native_configure },

	{ "start", "()V", (void *)android_media_MediaCodec_start },
	{ "stop", "()V", (void *)android_media_MediaCodec_stop },
	{ "flush", "()V", (void *)android_media_MediaCodec_flush },

	{ "queueInputBuffer", "(IIIJI)V",
	(void *)android_media_MediaCodec_queueInputBuffer },

	{ "dequeueInputBuffer", "(J)I",
	(void *)android_media_MediaCodec_dequeueInputBuffer },

	{ "dequeueOutputBuffer", "(Landroid/media/MediaCodec$BufferInfo;J)I",
	(void *)android_media_MediaCodec_dequeueOutputBuffer },

	{ "releaseOutputBuffer", "(IZ)V",
	(void *)android_media_MediaCodec_releaseOutputBuffer },

	{ "getOutputFormat", "()Ljava/util/Map;",
	(void *)android_media_MediaCodec_getOutputFormat },

	{ "getBuffers", "(Z)[Ljava/nio/ByteBuffer;",
	(void *)android_media_MediaCodec_getBuffers },

	{ "native_init", "()V", (void *)android_media_MediaCodec_native_init },

	{ "native_setup", "(Ljava/lang/String;ZZ)V",
	(void *)android_media_MediaCodec_native_setup },

	{ "native_finalize", "()V",
	(void *)android_media_MediaCodec_native_finalize },
	};

	int register_android_media_MediaCodec(JNIEnv *env) {
	return AndroidRuntime::registerNativeMethods(env,
	"android/media/MediaCodec", gMethods, NELEM(gMethods));
	}