Lines Matching defs:env
105 JNIEnv *env, jobject thiz,
109 jclass clazz = env->GetObjectClass(thiz);
112 mClass = (jclass)env->NewGlobalRef(clazz);
113 mObject = env->NewWeakGlobalRef(thiz);
115 cacheJavaObjects(env);
133 void JMediaCodec::cacheJavaObjects(JNIEnv *env) {
134 jclass clazz = (jclass)env->FindClass("java/nio/ByteBuffer");
135 mByteBufferClass = (jclass)env->NewGlobalRef(clazz);
139 env, env->FindClass("java/nio/ByteOrder"));
142 jmethodID nativeOrderID = env->GetStaticMethodID(
147 env->CallStaticObjectMethod(byteOrderClass.get(), nativeOrderID);
148 mNativeByteOrderObj = env->NewGlobalRef(nativeByteOrderObj);
150 env->DeleteLocalRef(nativeByteOrderObj);
153 mByteBufferOrderMethodID = env->GetMethodID(
159 mByteBufferAsReadOnlyBufferMethodID = env->GetMethodID(
163 mByteBufferPositionMethodID = env->GetMethodID(
167 mByteBufferLimitMethodID = env->GetMethodID(
210 JNIEnv *env = AndroidRuntime::getJNIEnv();
212 env->DeleteWeakGlobalRef(mObject);
214 env->DeleteGlobalRef(mClass);
216 deleteJavaObjects(env);
219 void JMediaCodec::deleteJavaObjects(JNIEnv *env) {
220 env->DeleteGlobalRef(mByteBufferClass);
222 env->DeleteGlobalRef(mNativeByteOrderObj);
341 JNIEnv *env, jobject bufferInfo, size_t *index, int64_t timeoutUs) {
353 env, env->FindClass("android/media/MediaCodec$BufferInfo"));
355 jmethodID method = env->GetMethodID(clazz.get(), "set", "(IIJI)V");
356 env->CallVoidMethod(bufferInfo, method, (jint)offset, (jint)size, timeUs, flags);
375 status_t JMediaCodec::getFormat(JNIEnv *env, bool input, jobject *format) const {
383 return ConvertMessageToMap(env, msg, format);
386 status_t JMediaCodec::getOutputFormat(JNIEnv *env, size_t index, jobject *format) const {
393 return ConvertMessageToMap(env, msg, format);
397 JNIEnv *env, bool input, jobjectArray *bufArray) const {
409 *bufArray = (jobjectArray)env->NewObjectArray(
420 env, !input /* readOnly */, true /* clearBuffer */, buffer, &byteBuffer);
425 env->SetObjectArrayElement(
428 env->DeleteLocalRef(byteBuffer);
438 JNIEnv *env, bool readOnly, bool clearBuffer, const sp<ABuffer> &buffer,
448 env->NewDirectByteBuffer(buffer->base(), buffer->capacity());
450 jobject readOnlyBuffer = env->CallObjectMethod(
452 env->DeleteLocalRef(byteBuffer);
458 jobject me = env->CallObjectMethod(
460 env->DeleteLocalRef(me);
461 me = env->CallObjectMethod(
464 env->DeleteLocalRef(me);
465 me = env->CallObjectMethod(
468 env->DeleteLocalRef(me);
476 JNIEnv *env, bool input, size_t index, jobject *buf) const {
489 env, !input /* readOnly */, input /* clearBuffer */, buffer, buf);
493 JNIEnv *env, bool input, size_t index, jobject *buf) const {
525 env, !input /* readOnly */, input /* clearBuffer */, buffer, &byteBuffer);
532 env, true /* readOnly */, true /* clearBuffer */, imageData, &infoBuffer);
534 env->DeleteLocalRef(byteBuffer);
543 env, env->FindClass("android/graphics/Rect"));
546 jmethodID rectConstructID = env->GetMethodID(
549 cropRect = env->NewObject(
554 env, env
557 jmethodID imageConstructID = env->GetMethodID(imageClazz.get(), "<init>",
560 *buf = env->NewObject(imageClazz.get(), imageConstructID,
567 if (env->ExceptionCheck()) {
568 env->ExceptionDescribe();
569 env->ExceptionClear();
574 env->DeleteLocalRef(cropRect);
578 env->DeleteLocalRef(byteBuffer);
581 env->DeleteLocalRef(infoBuffer);
587 status_t JMediaCodec::getName(JNIEnv *env, jstring *nameStr) const {
596 *nameStr = env->NewStringUTF(name.c_str());
612 JNIEnv *env, status_t err, int32_t actionCode, const char *msg = NULL) {
614 env, env->FindClass("android/media/MediaCodec$CodecException"));
617 const jmethodID ctor = env->GetMethodID(clazz.get(), "<init>", "(IILjava/lang/String;)V");
621 env, env->NewStringUTF(msg != NULL ? msg : String8::format("Error %#x", err)));
648 return (jthrowable)env->NewObject(clazz.get(), ctor, err, actionCode, msgObj.get());
655 JNIEnv *env = AndroidRuntime::getJNIEnv();
677 env, env->FindClass("android/media/MediaCodec$BufferInfo"));
678 jmethodID ctor = env->GetMethodID(clazz.get(), "<init>", "()V");
679 jmethodID method = env->GetMethodID(clazz.get(), "set", "(IIJI)V");
681 obj = env->NewObject(clazz.get(), ctor);
684 if (env->ExceptionCheck()) {
686 env->ExceptionClear();
688 jniThrowException(env, "java/lang/IllegalStateException", NULL);
692 env->CallVoidMethod(obj, method, (jint)offset, (jint)size, timeUs, flags);
703 obj = (jobject)createCodecException(env, err, actionCode);
706 if (env->ExceptionCheck()) {
708 env->ExceptionClear();
710 jniThrowException(env, "java/lang/IllegalStateException", NULL);
722 if (OK != ConvertMessageToMap(env, format, &obj)) {
723 jniThrowException(env, "java/lang/IllegalStateException", NULL);
734 env->CallVoidMethod(
742 env->DeleteLocalRef(obj);
748 JNIEnv *env = AndroidRuntime::getJNIEnv();
753 status_t err = ConvertMessageToMap(env, data, &obj);
755 jniThrowException(env, "java/lang/IllegalStateException", NULL);
759 env->CallVoidMethod(
763 env->DeleteLocalRef(obj);
790 JNIEnv *env, jobject thiz, const sp<JMediaCodec> &codec) {
791 sp<JMediaCodec> old = (JMediaCodec *)env->GetLongField(thiz, gFields.context);
804 env->SetLongField(thiz, gFields.context, (jlong)codec.get());
809 static sp<JMediaCodec> getMediaCodec(JNIEnv *env, jobject thiz) {
810 return (JMediaCodec *)env->GetLongField(thiz, gFields.context);
813 static void android_media_MediaCodec_release(JNIEnv *env, jobject thiz) {
814 setMediaCodec(env, thiz, NULL);
817 static void throwCodecException(JNIEnv *env, status_t err, int32_t actionCode, const char *msg) {
818 jthrowable exception = createCodecException(env, err, actionCode, msg);
819 env->Throw(exception);
822 static void throwCryptoException(JNIEnv *env, status_t err, const char *msg) {
824 env, env->FindClass("android/media/MediaCodec$CryptoException"));
828 env->GetMethodID(clazz.get(), "<init>", "(ILjava/lang/String;)V");
831 jstring msgObj = env->NewStringUTF(msg != NULL ? msg : "Unknown Error");
855 (jthrowable)env->NewObject(clazz.get(), constructID, err, msgObj);
857 env->Throw(exception);
861 JNIEnv *env, status_t err, int32_t actionCode = ACTION_CODE_FATAL,
877 jniThrowException(env, "java/lang/IllegalStateException", msg);
881 jniThrowException(env, "java/lang/IllegalArgumentException", msg);
886 throwCryptoException(env, err, msg);
889 throwCodecException(env, err, actionCode, msg);
895 JNIEnv *env,
898 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
901 throwExceptionAsNecessary(env, INVALID_OPERATION);
907 throwExceptionAsNecessary(env, err);
911 JNIEnv *env,
914 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
917 throwExceptionAsNecessary(env, INVALID_OPERATION);
923 throwExceptionAsNecessary(env, err);
927 JNIEnv *env,
933 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
936 throwExceptionAsNecessary(env, INVALID_OPERATION);
941 status_t err = ConvertKeyValueArraysToMessage(env, keys, values, &format);
944 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
950 sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
955 env,
964 crypto = JCrypto::GetCrypto(env, jcrypto);
969 throwExceptionAsNecessary(env, err);
973 JNIEnv *env,
976 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
979 throwExceptionAsNecessary(env, INVALID_OPERATION);
985 sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
990 env,
998 throwExceptionAsNecessary(env, err);
1002 JNIEnv* env, jobject object) {
1005 jobject lock = env->GetObjectField(
1007 if (env->MonitorEnter(lock) == JNI_OK) {
1009 env->GetLongField(object,
1011 env->MonitorExit(lock);
1013 env->DeleteLocalRef(lock);
1019 JNIEnv* env, jclass /* clazz */) {
1034 jobject object = env->NewObject(
1039 if (env->ExceptionCheck()) {
1041 env->ExceptionClear();
1046 jobject lock = env->GetObjectField(
1048 if (env->MonitorEnter(lock) == JNI_OK) {
1049 env->CallVoidMethod(
1053 env->SetLongField(
1057 env->MonitorExit(lock);
1059 env->DeleteLocalRef(object);
1062 env->DeleteLocalRef(lock);
1073 JNIEnv* env, jclass /* clazz */, jobject object) {
1076 jobject lock = env->GetObjectField(
1078 if (env->MonitorEnter(lock) == JNI_OK) {
1080 env->GetLongField(
1082 env->SetLongField(
1086 env->MonitorExit(lock);
1088 env->DeleteLocalRef(lock);
1097 JNIEnv* env, jobject thiz, jobject object) {
1100 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1102 throwExceptionAsNecessary(env, INVALID_OPERATION);
1107 android_media_MediaCodec_getPersistentInputSurface(env, object);
1111 throwExceptionAsNecessary(env, err);
1115 static jobject android_media_MediaCodec_createInputSurface(JNIEnv* env,
1119 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1121 throwExceptionAsNecessary(env, INVALID_OPERATION);
1129 throwExceptionAsNecessary(env, err);
1134 return android_view_Surface_createFromIGraphicBufferProducer(env,
1138 static void android_media_MediaCodec_start(JNIEnv *env, jobject thiz) {
1141 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1144 throwExceptionAsNecessary(env, INVALID_OPERATION);
1150 throwExceptionAsNecessary(env, err, ACTION_CODE_FATAL, "start failed");
1153 static void android_media_MediaCodec_stop(JNIEnv *env, jobject thiz) {
1156 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1159 throwExceptionAsNecessary(env, INVALID_OPERATION);
1165 throwExceptionAsNecessary(env, err);
1168 static void android_media_MediaCodec_reset(JNIEnv *env, jobject thiz) {
1171 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1174 throwExceptionAsNecessary(env, INVALID_OPERATION);
1187 throwExceptionAsNecessary(env, err);
1190 static void android_media_MediaCodec_flush(JNIEnv *env, jobject thiz) {
1193 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1196 throwExceptionAsNecessary(env, INVALID_OPERATION);
1202 throwExceptionAsNecessary(env, err);
1206 JNIEnv *env,
1215 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1218 throwExceptionAsNecessary(env, INVALID_OPERATION);
1228 env, err, ACTION_CODE_FATAL, errorDetailMsg.empty() ? NULL : errorDetailMsg.c_str());
1232 JNIEnv *env,
1241 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1244 throwExceptionAsNecessary(env, INVALID_OPERATION);
1249 env->GetIntField(cryptoInfoObj, gFields.cryptoInfoNumSubSamplesID);
1252 (jintArray)env->GetObjectField(
1256 (jintArray)env->GetObjectField(
1260 (jbyteArray)env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoKeyID);
1263 (jbyteArray)env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoIVID);
1265 jint mode = env->GetIntField(cryptoInfoObj, gFields.cryptoInfoModeID);
1279 && env->GetArrayLength(numBytesOfEncryptedDataObj) < numSubSamples) {
1282 && env->GetArrayLength(numBytesOfClearDataObj) < numSubSamples) {
1294 : env->GetIntArrayElements(numBytesOfClearDataObj, &isCopy);
1299 : env->GetIntArrayElements(numBytesOfEncryptedDataObj, &isCopy);
1313 env->ReleaseIntArrayElements(
1319 env->ReleaseIntArrayElements(
1326 if (env->GetArrayLength(keyObj) != 16) {
1330 key = env->GetByteArrayElements(keyObj, &isCopy);
1335 if (env->GetArrayLength(ivObj) != 16) {
1339 iv = env->GetByteArrayElements(ivObj, &isCopy);
1357 env->ReleaseByteArrayElements(ivObj, iv, 0);
1362 env->ReleaseByteArrayElements(keyObj, key, 0);
1370 env, err, ACTION_CODE_FATAL, errorDetailMsg.empty() ? NULL : errorDetailMsg.c_str());
1374 JNIEnv *env, jobject thiz, jlong timeoutUs) {
1377 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1380 throwExceptionAsNecessary(env, INVALID_OPERATION);
1391 return throwExceptionAsNecessary(env, err);
1395 JNIEnv *env, jobject thiz, jobject bufferInfo, jlong timeoutUs) {
1398 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1401 throwExceptionAsNecessary(env, INVALID_OPERATION);
1407 env, bufferInfo, &index, timeoutUs);
1413 return throwExceptionAsNecessary(env, err);
1417 JNIEnv *env, jobject thiz,
1421 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1424 throwExceptionAsNecessary(env, INVALID_OPERATION);
1430 throwExceptionAsNecessary(env, err);
1433 static void android_media_MediaCodec_signalEndOfInputStream(JNIEnv* env,
1437 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1439 throwExceptionAsNecessary(env, INVALID_OPERATION);
1445 throwExceptionAsNecessary(env, err);
1449 JNIEnv *env, jobject thiz, jboolean input) {
1452 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1455 throwExceptionAsNecessary(env, INVALID_OPERATION);
1460 status_t err = codec->getFormat(env, input, &format);
1466 throwExceptionAsNecessary(env, err);
1472 JNIEnv *env, jobject thiz, jint index) {
1475 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1478 throwExceptionAsNecessary(env, INVALID_OPERATION);
1483 status_t err = codec->getOutputFormat(env, index, &format);
1489 throwExceptionAsNecessary(env, err);
1495 JNIEnv *env, jobject thiz, jboolean input) {
1498 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1501 throwExceptionAsNecessary(env, INVALID_OPERATION);
1506 status_t err = codec->getBuffers(env, input, &buffers);
1514 throwExceptionAsNecessary(env, err);
1521 JNIEnv *env, jobject thiz, jboolean input, jint index) {
1524 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1527 throwExceptionAsNecessary(env, INVALID_OPERATION);
1532 status_t err = codec->getBuffer(env, input, index, &buffer);
1540 throwExceptionAsNecessary(env, err);
1547 JNIEnv *env, jobject thiz, jboolean input, jint index) {
1550 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1553 throwExceptionAsNecessary(env, INVALID_OPERATION);
1558 status_t err = codec->getImage(env, input, index, &image);
1566 throwExceptionAsNecessary(env, err);
1573 JNIEnv *env, jobject thiz) {
1576 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1579 throwExceptionAsNecessary(env, INVALID_OPERATION);
1584 status_t err = codec->getName(env, &name);
1590 throwExceptionAsNecessary(env, err);
1596 JNIEnv *env, jobject thiz, jobjectArray keys, jobjectArray vals) {
1599 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1602 throwExceptionAsNecessary(env, INVALID_OPERATION);
1607 status_t err = ConvertKeyValueArraysToMessage(env, keys, vals, ¶ms);
1613 throwExceptionAsNecessary(env, err);
1617 JNIEnv *env, jobject thiz, jint mode) {
1618 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1621 throwExceptionAsNecessary(env, INVALID_OPERATION);
1627 jniThrowException(env, "java/lang/InvalidArgumentException", NULL);
1634 static void android_media_MediaCodec_native_init(JNIEnv *env) {
1636 env, env->FindClass("android/media/MediaCodec"));
1639 gFields.context = env->GetFieldID(clazz.get(), "mNativeContext", "J");
1643 env->GetMethodID(
1648 clazz.reset(env->FindClass("android/media/MediaCodec$CryptoInfo"));
1652 env->GetFieldID(clazz.get(), "numSubSamples", "I");
1656 env->GetFieldID(clazz.get(), "numBytesOfClearData", "[I");
1660 env->GetFieldID(clazz.get(), "numBytesOfEncryptedData", "[I");
1663 gFields.cryptoInfoKeyID = env->GetFieldID(clazz.get(), "key", "[B");
1666 gFields.cryptoInfoIVID = env->GetFieldID(clazz.get(), "iv", "[B");
1669 gFields.cryptoInfoModeID = env->GetFieldID(clazz.get(), "mode", "I");
1672 clazz.reset(env
1676 field = env->GetStaticFieldID(clazz.get(), "ERROR_NO_KEY", "I");
1679 env->GetStaticIntField(clazz.get(), field);
1681 field = env->GetStaticFieldID(clazz.get(), "ERROR_KEY_EXPIRED", "I");
1684 env->GetStaticIntField(clazz.get(), field);
1686 field = env->GetStaticFieldID(clazz.get(), "ERROR_RESOURCE_BUSY", "I");
1689 env->GetStaticIntField(clazz.get(), field);
1691 field = env->GetStaticFieldID(clazz.get(), "ERROR_INSUFFICIENT_OUTPUT_PROTECTION", "I");
1694 env->GetStaticIntField(clazz.get(), field);
1696 field = env->GetStaticFieldID(clazz.get(), "ERROR_SESSION_NOT_OPENED", "I");
1699 env->GetStaticIntField(clazz.get(), field);
1701 clazz.reset(env->FindClass("android/media/MediaCodec$CodecException"));
1703 field = env->GetStaticFieldID(clazz.get(), "ACTION_TRANSIENT", "I");
1706 env->GetStaticIntField(clazz.get(), field);
1708 field = env->GetStaticFieldID(clazz.get(), "ACTION_RECOVERABLE", "I");
1711 env->GetStaticIntField(clazz.get(), field);
1713 field = env->GetStaticFieldID(clazz.get(), "ERROR_INSUFFICIENT_RESOURCE", "I");
1716 env->GetStaticIntField(clazz.get(), field);
1718 field = env->GetStaticFieldID(clazz.get(), "ERROR_RECLAIMED", "I");
1721 env->GetStaticIntField(clazz.get(), field);
1723 clazz.reset(env->FindClass("android/view/Surface"));
1726 field = env->GetFieldID(clazz.get(), "mLock", "Ljava/lang/Object;");
1730 jmethodID method = env->GetMethodID(clazz.get(), "setNativeObjectLocked", "(J)V");
1734 clazz.reset(env->FindClass("android/media/MediaCodec$PersistentSurface"));
1736 gPersistentSurfaceClassInfo.clazz = (jclass)env->NewGlobalRef(clazz.get());
1738 method = env->GetMethodID(clazz.get(), "<init>", "()V");
1742 field = env->GetFieldID(clazz.get(), "mPersistentObject", "J");
1748 JNIEnv *env, jobject thiz,
1751 jniThrowException(env, "java/lang/NullPointerException", NULL);
1755 const char *tmp = env->GetStringUTFChars(name, NULL);
1761 sp<JMediaCodec> codec = new JMediaCodec(env, thiz, tmp, nameIsType, encoder);
1766 jniThrowException(env, "java/lang/IllegalArgumentException",
1768 env->ReleaseStringUTFChars(name, tmp);
1771 throwCodecException(env, err, ACTION_CODE_TRANSIENT,
1773 env->ReleaseStringUTFChars(name, tmp);
1777 jniThrowException(env, "java/io/IOException",
1779 env->ReleaseStringUTFChars(name, tmp);
1783 env->ReleaseStringUTFChars(name, tmp);
1787 setMediaCodec(env,thiz, codec);
1791 JNIEnv *env, jobject thiz) {
1792 android_media_MediaCodec_release(env, thiz);
1885 int register_android_media_MediaCodec(JNIEnv *env) {
1886 return AndroidRuntime::registerNativeMethods(env,
