Lines Matching defs:env
116 JNIEnv *env, jobject thiz,
120 jclass clazz = env->GetObjectClass(thiz);
123 mClass = (jclass)env->NewGlobalRef(clazz);
124 mObject = env->NewWeakGlobalRef(thiz);
126 cacheJavaObjects(env);
144 void JMediaCodec::cacheJavaObjects(JNIEnv *env) {
145 jclass clazz = (jclass)env->FindClass("java/nio/ByteBuffer");
146 mByteBufferClass = (jclass)env->NewGlobalRef(clazz);
150 env, env->FindClass("java/nio/ByteOrder"));
153 jmethodID nativeOrderID = env->GetStaticMethodID(
158 env->CallStaticObjectMethod(byteOrderClass.get(), nativeOrderID);
159 mNativeByteOrderObj = env->NewGlobalRef(nativeByteOrderObj);
161 env->DeleteLocalRef(nativeByteOrderObj);
164 mByteBufferOrderMethodID = env->GetMethodID(
170 mByteBufferAsReadOnlyBufferMethodID = env->GetMethodID(
174 mByteBufferPositionMethodID = env->GetMethodID(
178 mByteBufferLimitMethodID = env->GetMethodID(
221 JNIEnv *env = AndroidRuntime::getJNIEnv();
223 env->DeleteWeakGlobalRef(mObject);
225 env->DeleteGlobalRef(mClass);
227 deleteJavaObjects(env);
230 void JMediaCodec::deleteJavaObjects(JNIEnv *env) {
231 env->DeleteGlobalRef(mByteBufferClass);
233 env->DeleteGlobalRef(mNativeByteOrderObj);
353 JNIEnv *env, jobject bufferInfo, size_t *index, int64_t timeoutUs) {
365 env, env->FindClass("android/media/MediaCodec$BufferInfo"));
367 jmethodID method = env->GetMethodID(clazz.get(), "set", "(IIJI)V");
368 env->CallVoidMethod(bufferInfo, method, (jint)offset, (jint)size, timeUs, flags);
387 status_t JMediaCodec::getFormat(JNIEnv *env, bool input, jobject *format) const {
395 return ConvertMessageToMap(env, msg, format);
398 status_t JMediaCodec::getOutputFormat(JNIEnv *env, size_t index, jobject *format) const {
405 return ConvertMessageToMap(env, msg, format);
409 JNIEnv *env, bool input, jobjectArray *bufArray) const {
421 *bufArray = (jobjectArray)env->NewObjectArray(
432 env, !input /* readOnly */, true /* clearBuffer */, buffer, &byteBuffer);
437 env->SetObjectArrayElement(
440 env->DeleteLocalRef(byteBuffer);
450 JNIEnv *env, bool readOnly, bool clearBuffer, const sp<ABuffer> &buffer,
466 env->NewDirectByteBuffer(buffer->base(), buffer->capacity());
468 jobject readOnlyBuffer = env->CallObjectMethod(
470 env->DeleteLocalRef(byteBuffer);
476 jobject me = env->CallObjectMethod(
478 env->DeleteLocalRef(me);
479 me = env->CallObjectMethod(
482 env->DeleteLocalRef(me);
483 me = env->CallObjectMethod(
486 env->DeleteLocalRef(me);
494 JNIEnv *env, bool input, size_t index, jobject *buf) const {
507 env, !input /* readOnly */, input /* clearBuffer */, buffer, buf);
511 JNIEnv *env, bool input, size_t index, jobject *buf) const {
543 env, !input /* readOnly */, input /* clearBuffer */, buffer, &byteBuffer);
550 env, true /* readOnly */, true /* clearBuffer */, imageData, &infoBuffer);
552 env->DeleteLocalRef(byteBuffer);
561 env, env->FindClass("android/graphics/Rect"));
564 jmethodID rectConstructID = env->GetMethodID(
567 cropRect = env->NewObject(
572 env, env->FindClass("android/media/MediaCodec$MediaImage"));
575 jmethodID imageConstructID = env->GetMethodID(imageClazz.get(), "<init>",
578 *buf = env->NewObject(imageClazz.get(), imageConstructID,
585 if (env->ExceptionCheck()) {
586 env->ExceptionDescribe();
587 env->ExceptionClear();
592 env->DeleteLocalRef(cropRect);
596 env->DeleteLocalRef(byteBuffer);
599 env->DeleteLocalRef(infoBuffer);
605 status_t JMediaCodec::getName(JNIEnv *env, jstring *nameStr) const {
614 *nameStr = env->NewStringUTF(name.c_str());
630 JNIEnv *env, status_t err, int32_t actionCode, const char *msg = NULL) {
632 env, env->FindClass("android/media/MediaCodec$CodecException"));
635 const jmethodID ctor = env->GetMethodID(clazz.get(), "<init>", "(IILjava/lang/String;)V");
639 env, env->NewStringUTF(msg != NULL ? msg : String8::format("Error %#x", err)));
666 return (jthrowable)env->NewObject(clazz.get(), ctor, err, actionCode, msgObj.get());
673 JNIEnv *env = AndroidRuntime::getJNIEnv();
695 env, env->FindClass("android/media/MediaCodec$BufferInfo"));
696 jmethodID ctor = env->GetMethodID(clazz.get(), "<init>", "()V");
697 jmethodID method = env->GetMethodID(clazz.get(), "set", "(IIJI)V");
699 obj = env->NewObject(clazz.get(), ctor);
702 if (env->ExceptionCheck()) {
704 env->ExceptionClear();
706 jniThrowException(env, "java/lang/IllegalStateException", NULL);
710 env->CallVoidMethod(obj, method, (jint)offset, (jint)size, timeUs, flags);
721 obj = (jobject)createCodecException(env, err, actionCode);
724 if (env->ExceptionCheck()) {
726 env->ExceptionClear();
728 jniThrowException(env, "java/lang/IllegalStateException", NULL);
740 if (OK != ConvertMessageToMap(env, format, &obj)) {
741 jniThrowException(env, "java/lang/IllegalStateException", NULL);
752 env->CallVoidMethod(
760 env->DeleteLocalRef(obj);
766 JNIEnv *env = AndroidRuntime::getJNIEnv();
771 status_t err = ConvertMessageToMap(env, data, &obj);
773 jniThrowException(env, "java/lang/IllegalStateException", NULL);
777 env->CallVoidMethod(
781 env->DeleteLocalRef(obj);
808 JNIEnv *env, jobject thiz, const sp<JMediaCodec> &codec) {
809 sp<JMediaCodec> old = (JMediaCodec *)env->GetLongField(thiz, gFields.context);
822 env->SetLongField(thiz, gFields.context, (jlong)codec.get());
827 static sp<JMediaCodec> getMediaCodec(JNIEnv *env, jobject thiz) {
828 return (JMediaCodec *)env->GetLongField(thiz, gFields.context);
831 static void android_media_MediaCodec_release(JNIEnv *env, jobject thiz) {
832 setMediaCodec(env, thiz, NULL);
835 static void throwCodecException(JNIEnv *env, status_t err, int32_t actionCode, const char *msg) {
836 jthrowable exception = createCodecException(env, err, actionCode, msg);
837 env->Throw(exception);
840 static void throwCryptoException(JNIEnv *env, status_t err, const char *msg) {
842 env, env->FindClass("android/media/MediaCodec$CryptoException"));
846 env->GetMethodID(clazz.get(), "<init>", "(ILjava/lang/String;)V");
881 jstring msgObj = env->NewStringUTF(msg != NULL ? msg : defaultMsg);
884 (jthrowable)env->NewObject(clazz.get(), constructID, err, msgObj);
886 env->Throw(exception);
890 JNIEnv *env, status_t err, int32_t actionCode = ACTION_CODE_FATAL,
906 jniThrowException(env, "java/lang/IllegalStateException", msg);
910 jniThrowException(env, "java/lang/IllegalArgumentException", msg);
915 throwCryptoException(env, err, msg);
918 throwCodecException(env, err, actionCode, msg);
924 JNIEnv *env,
927 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
930 throwExceptionAsNecessary(env, INVALID_OPERATION);
936 throwExceptionAsNecessary(env, err);
940 JNIEnv *env,
943 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
946 throwExceptionAsNecessary(env, INVALID_OPERATION);
952 throwExceptionAsNecessary(env, err);
956 JNIEnv *env,
962 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
965 throwExceptionAsNecessary(env, INVALID_OPERATION);
970 status_t err = ConvertKeyValueArraysToMessage(env, keys, values, &format);
973 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
979 sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
984 env,
993 crypto = JCrypto::GetCrypto(env, jcrypto);
998 throwExceptionAsNecessary(env, err);
1002 JNIEnv *env,
1005 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1008 throwExceptionAsNecessary(env, INVALID_OPERATION);
1014 sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
1019 env,
1027 throwExceptionAsNecessary(env, err);
1031 JNIEnv* env, jobject object) {
1034 jobject lock = env->GetObjectField(
1036 if (env->MonitorEnter(lock) == JNI_OK) {
1038 env->GetLongField(object,
1040 env->MonitorExit(lock);
1042 env->DeleteLocalRef(lock);
1048 JNIEnv* env, jclass /* clazz */) {
1063 jobject object = env->NewObject(
1068 if (env->ExceptionCheck()) {
1070 env->ExceptionClear();
1075 jobject lock = env->GetObjectField(
1077 if (env->MonitorEnter(lock) == JNI_OK) {
1078 env->CallVoidMethod(
1082 env->SetLongField(
1086 env->MonitorExit(lock);
1088 env->DeleteLocalRef(object);
1091 env->DeleteLocalRef(lock);
1102 JNIEnv* env, jclass /* clazz */, jobject object) {
1105 jobject lock = env->GetObjectField(
1107 if (env->MonitorEnter(lock) == JNI_OK) {
1109 env->GetLongField(
1111 env->SetLongField(
1115 env->MonitorExit(lock);
1117 env->DeleteLocalRef(lock);
1126 JNIEnv* env, jobject thiz, jobject object) {
1129 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1131 throwExceptionAsNecessary(env, INVALID_OPERATION);
1136 android_media_MediaCodec_getPersistentInputSurface(env, object);
1140 throwExceptionAsNecessary(env, err);
1144 static jobject android_media_MediaCodec_createInputSurface(JNIEnv* env,
1148 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1150 throwExceptionAsNecessary(env, INVALID_OPERATION);
1158 throwExceptionAsNecessary(env, err);
1163 return android_view_Surface_createFromIGraphicBufferProducer(env,
1167 static void android_media_MediaCodec_start(JNIEnv *env, jobject thiz) {
1170 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1173 throwExceptionAsNecessary(env, INVALID_OPERATION);
1179 throwExceptionAsNecessary(env, err, ACTION_CODE_FATAL, "start failed");
1182 static void android_media_MediaCodec_stop(JNIEnv *env, jobject thiz) {
1185 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1188 throwExceptionAsNecessary(env, INVALID_OPERATION);
1194 throwExceptionAsNecessary(env, err);
1197 static void android_media_MediaCodec_reset(JNIEnv *env, jobject thiz) {
1200 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1203 throwExceptionAsNecessary(env, INVALID_OPERATION);
1216 throwExceptionAsNecessary(env, err);
1219 static void android_media_MediaCodec_flush(JNIEnv *env, jobject thiz) {
1222 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1225 throwExceptionAsNecessary(env, INVALID_OPERATION);
1231 throwExceptionAsNecessary(env, err);
1235 JNIEnv *env,
1244 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1247 throwExceptionAsNecessary(env, INVALID_OPERATION);
1257 env, err, ACTION_CODE_FATAL, errorDetailMsg.empty() ? NULL : errorDetailMsg.c_str());
1261 JNIEnv *env,
1270 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1273 throwExceptionAsNecessary(env, INVALID_OPERATION);
1278 env->GetIntField(cryptoInfoObj, gFields.cryptoInfoNumSubSamplesID);
1281 (jintArray)env->GetObjectField(
1285 (jintArray)env->GetObjectField(
1289 (jbyteArray)env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoKeyID);
1292 (jbyteArray)env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoIVID);
1294 jint jmode = env->GetIntField(cryptoInfoObj, gFields.cryptoInfoModeID);
1303 throwExceptionAsNecessary(env, INVALID_OPERATION);
1307 jobject patternObj = env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoPatternID);
1314 pattern.mEncryptBlocks = env->GetIntField(patternObj, gFields.patternEncryptBlocksID);
1315 pattern.mSkipBlocks = env->GetIntField(patternObj, gFields.patternSkipBlocksID);
1330 && env->GetArrayLength(numBytesOfEncryptedDataObj) < numSubSamples) {
1333 && env->GetArrayLength(numBytesOfClearDataObj) < numSubSamples) {
1345 : env->GetIntArrayElements(numBytesOfClearDataObj, &isCopy);
1350 : env->GetIntArrayElements(numBytesOfEncryptedDataObj, &isCopy);
1364 env->ReleaseIntArrayElements(
1370 env->ReleaseIntArrayElements(
1377 if (env->GetArrayLength(keyObj) != 16) {
1381 key = env->GetByteArrayElements(keyObj, &isCopy);
1386 if (env->GetArrayLength(ivObj) != 16) {
1390 iv = env->GetByteArrayElements(ivObj, &isCopy);
1409 env->ReleaseByteArrayElements(ivObj, iv, 0);
1414 env->ReleaseByteArrayElements(keyObj, key, 0);
1422 env, err, ACTION_CODE_FATAL, errorDetailMsg.empty() ? NULL : errorDetailMsg.c_str());
1426 JNIEnv *env, jobject thiz, jlong timeoutUs) {
1429 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1432 throwExceptionAsNecessary(env, INVALID_OPERATION);
1443 return throwExceptionAsNecessary(env, err);
1447 JNIEnv *env, jobject thiz, jobject bufferInfo, jlong timeoutUs) {
1450 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1453 throwExceptionAsNecessary(env, INVALID_OPERATION);
1459 env, bufferInfo, &index, timeoutUs);
1465 return throwExceptionAsNecessary(env, err);
1469 JNIEnv *env, jobject thiz,
1473 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1476 throwExceptionAsNecessary(env, INVALID_OPERATION);
1482 throwExceptionAsNecessary(env, err);
1485 static void android_media_MediaCodec_signalEndOfInputStream(JNIEnv* env,
1489 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1491 throwExceptionAsNecessary(env, INVALID_OPERATION);
1497 throwExceptionAsNecessary(env, err);
1501 JNIEnv *env, jobject thiz, jboolean input) {
1504 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1507 throwExceptionAsNecessary(env, INVALID_OPERATION);
1512 status_t err = codec->getFormat(env, input, &format);
1518 throwExceptionAsNecessary(env, err);
1524 JNIEnv *env, jobject thiz, jint index) {
1527 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1530 throwExceptionAsNecessary(env, INVALID_OPERATION);
1535 status_t err = codec->getOutputFormat(env, index, &format);
1541 throwExceptionAsNecessary(env, err);
1547 JNIEnv *env, jobject thiz, jboolean input) {
1550 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1553 throwExceptionAsNecessary(env, INVALID_OPERATION);
1558 status_t err = codec->getBuffers(env, input, &buffers);
1566 throwExceptionAsNecessary(env, err);
1573 JNIEnv *env, jobject thiz, jboolean input, jint index) {
1576 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1579 throwExceptionAsNecessary(env, INVALID_OPERATION);
1584 status_t err = codec->getBuffer(env, input, index, &buffer);
1592 throwExceptionAsNecessary(env, err);
1599 JNIEnv *env, jobject thiz, jboolean input, jint index) {
1602 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1605 throwExceptionAsNecessary(env, INVALID_OPERATION);
1610 status_t err = codec->getImage(env, input, index, &image);
1618 throwExceptionAsNecessary(env, err);
1625 JNIEnv *env, jobject thiz) {
1628 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1631 throwExceptionAsNecessary(env, INVALID_OPERATION);
1636 status_t err = codec->getName(env, &name);
1642 throwExceptionAsNecessary(env, err);
1648 JNIEnv *env, jobject thiz, jobjectArray keys, jobjectArray vals) {
1651 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1654 throwExceptionAsNecessary(env, INVALID_OPERATION);
1659 status_t err = ConvertKeyValueArraysToMessage(env, keys, vals, ¶ms);
1665 throwExceptionAsNecessary(env, err);
1669 JNIEnv *env, jobject thiz, jint mode) {
1670 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1673 throwExceptionAsNecessary(env, INVALID_OPERATION);
1679 jniThrowException(env, "java/lang/InvalidArgumentException", NULL);
1686 static void android_media_MediaCodec_native_init(JNIEnv *env) {
1688 env, env->FindClass("android/media/MediaCodec"));
1691 gFields.context = env->GetFieldID(clazz.get(), "mNativeContext", "J");
1695 env->GetMethodID(
1701 field = env->GetStaticFieldID(clazz.get(), "CRYPTO_MODE_UNENCRYPTED", "I");
1704 env->GetStaticIntField(clazz.get(), field);
1706 field = env->GetStaticFieldID(clazz.get(), "CRYPTO_MODE_AES_CTR", "I");
1709 env->GetStaticIntField(clazz.get(), field);
1711 field = env->GetStaticFieldID(clazz.get(), "CRYPTO_MODE_AES_CBC", "I");
1714 env->GetStaticIntField(clazz.get(), field);
1716 clazz.reset(env->FindClass("android/media/MediaCodec$CryptoInfo"));
1720 env->GetFieldID(clazz.get(), "numSubSamples", "I");
1724 env->GetFieldID(clazz.get(), "numBytesOfClearData", "[I");
1728 env->GetFieldID(clazz.get(), "numBytesOfEncryptedData", "[I");
1731 gFields.cryptoInfoKeyID = env->GetFieldID(clazz.get(), "key", "[B");
1734 gFields.cryptoInfoIVID = env->GetFieldID(clazz.get(), "iv", "[B");
1737 gFields.cryptoInfoModeID = env->GetFieldID(clazz.get(), "mode", "I");
1740 gFields.cryptoInfoPatternID = env->GetFieldID(clazz.get(), "pattern",
1744 clazz.reset(env->FindClass("android/media/MediaCodec$CryptoInfo$Pattern"));
1747 gFields.patternEncryptBlocksID = env->GetFieldID(clazz.get(), "mEncryptBlocks", "I");
1750 gFields.patternSkipBlocksID = env->GetFieldID(clazz.get(), "mSkipBlocks", "I");
1753 clazz.reset(env->FindClass("android/media/MediaCodec$CryptoException"));
1756 field = env->GetStaticFieldID(clazz.get(), "ERROR_NO_KEY", "I");
1759 env->GetStaticIntField(clazz.get(), field);
1761 field = env->GetStaticFieldID(clazz.get(), "ERROR_KEY_EXPIRED", "I");
1764 env->GetStaticIntField(clazz.get(), field);
1766 field = env->GetStaticFieldID(clazz.get(), "ERROR_RESOURCE_BUSY", "I");
1769 env->GetStaticIntField(clazz.get(), field);
1771 field = env->GetStaticFieldID(clazz.get(), "ERROR_INSUFFICIENT_OUTPUT_PROTECTION", "I");
1774 env->GetStaticIntField(clazz.get(), field);
1776 field = env->GetStaticFieldID(clazz.get(), "ERROR_SESSION_NOT_OPENED", "I");
1779 env->GetStaticIntField(clazz.get(), field);
1781 field = env->GetStaticFieldID(clazz.get(), "ERROR_UNSUPPORTED_OPERATION", "I");
1784 env->GetStaticIntField(clazz.get(), field);
1786 clazz.reset(env->FindClass("android/media/MediaCodec$CodecException"));
1788 field = env->GetStaticFieldID(clazz.get(), "ACTION_TRANSIENT", "I");
1791 env->GetStaticIntField(clazz.get(), field);
1793 field = env->GetStaticFieldID(clazz.get(), "ACTION_RECOVERABLE", "I");
1796 env->GetStaticIntField(clazz.get(), field);
1798 field = env->GetStaticFieldID(clazz.get(), "ERROR_INSUFFICIENT_RESOURCE", "I");
1801 env->GetStaticIntField(clazz.get(), field);
1803 field = env->GetStaticFieldID(clazz.get(), "ERROR_RECLAIMED", "I");
1806 env->GetStaticIntField(clazz.get(), field);
1808 clazz.reset(env->FindClass("android/view/Surface"));
1811 field = env->GetFieldID(clazz.get(), "mLock", "Ljava/lang/Object;");
1815 jmethodID method = env->GetMethodID(clazz.get(), "setNativeObjectLocked", "(J)V");
1819 clazz.reset(env->FindClass("android/media/MediaCodec$PersistentSurface"));
1821 gPersistentSurfaceClassInfo.clazz = (jclass)env->NewGlobalRef(clazz.get());
1823 method = env->GetMethodID(clazz.get(), "<init>", "()V");
1827 field = env->GetFieldID(clazz.get(), "mPersistentObject", "J");
1833 JNIEnv *env, jobject thiz,
1836 jniThrowException(env, "java/lang/NullPointerException", NULL);
1840 const char *tmp = env->GetStringUTFChars(name, NULL);
1846 sp<JMediaCodec> codec = new JMediaCodec(env, thiz, tmp, nameIsType, encoder);
1851 jniThrowException(env, "java/lang/IllegalArgumentException",
1853 env->ReleaseStringUTFChars(name, tmp);
1856 throwCodecException(env, err, ACTION_CODE_TRANSIENT,
1858 env->ReleaseStringUTFChars(name, tmp);
1862 jniThrowException(env, "java/io/IOException",
1864 env->ReleaseStringUTFChars(name, tmp);
1868 env->ReleaseStringUTFChars(name, tmp);
1872 setMediaCodec(env,thiz, codec);
1876 JNIEnv *env, jobject thiz) {
1877 android_media_MediaCodec_release(env, thiz);
1970 int register_android_media_MediaCodec(JNIEnv *env) {
1971 return AndroidRuntime::registerNativeMethods(env,