Lines Matching defs:env
121 JNIEnv *env, jobject thiz,
125 jclass clazz = env->GetObjectClass(thiz);
128 mClass = (jclass)env->NewGlobalRef(clazz);
129 mObject = env->NewWeakGlobalRef(thiz);
131 cacheJavaObjects(env);
149 void JMediaCodec::cacheJavaObjects(JNIEnv *env) {
150 jclass clazz = (jclass)env->FindClass("java/nio/ByteBuffer");
151 mByteBufferClass = (jclass)env->NewGlobalRef(clazz);
155 env, env->FindClass("java/nio/ByteOrder"));
158 jmethodID nativeOrderID = env->GetStaticMethodID(
163 env->CallStaticObjectMethod(byteOrderClass.get(), nativeOrderID);
164 mNativeByteOrderObj = env->NewGlobalRef(nativeByteOrderObj);
166 env->DeleteLocalRef(nativeByteOrderObj);
169 mByteBufferOrderMethodID = env->GetMethodID(
175 mByteBufferAsReadOnlyBufferMethodID = env->GetMethodID(
179 mByteBufferPositionMethodID = env->GetMethodID(
183 mByteBufferLimitMethodID = env->GetMethodID(
226 JNIEnv *env = AndroidRuntime::getJNIEnv();
228 env->DeleteWeakGlobalRef(mObject);
230 env->DeleteGlobalRef(mClass);
232 deleteJavaObjects(env);
235 void JMediaCodec::deleteJavaObjects(JNIEnv *env) {
236 env->DeleteGlobalRef(mByteBufferClass);
238 env->DeleteGlobalRef(mNativeByteOrderObj);
360 JNIEnv *env, jobject bufferInfo, size_t *index, int64_t timeoutUs) {
372 env, env->FindClass("android/media/MediaCodec$BufferInfo"));
374 jmethodID method = env->GetMethodID(clazz.get(), "set", "(IIJI)V");
375 env->CallVoidMethod(bufferInfo, method, (jint)offset, (jint)size, timeUs, flags);
394 status_t JMediaCodec::getFormat(JNIEnv *env, bool input, jobject *format) const {
402 return ConvertMessageToMap(env, msg, format);
405 status_t JMediaCodec::getOutputFormat(JNIEnv *env, size_t index, jobject *format) const {
412 return ConvertMessageToMap(env, msg, format);
416 JNIEnv *env, bool input, jobjectArray *bufArray) const {
428 *bufArray = (jobjectArray)env->NewObjectArray(
439 env, !input /* readOnly */, true /* clearBuffer */, buffer, &byteBuffer);
444 env->SetObjectArrayElement(
447 env->DeleteLocalRef(byteBuffer);
458 JNIEnv *env, bool readOnly, bool clearBuffer, const sp<T> &buffer,
474 env->NewDirectByteBuffer(buffer->base(), buffer->capacity());
476 jobject readOnlyBuffer = env->CallObjectMethod(
478 env->DeleteLocalRef(byteBuffer);
484 jobject me = env->CallObjectMethod(
486 env->DeleteLocalRef(me);
487 me = env->CallObjectMethod(
490 env->DeleteLocalRef(me);
491 me = env->CallObjectMethod(
494 env->DeleteLocalRef(me);
502 JNIEnv *env, bool input, size_t index, jobject *buf) const {
515 env, !input /* readOnly */, input /* clearBuffer */, buffer, buf);
519 JNIEnv *env, bool input, size_t index, jobject *buf) const {
551 env, !input /* readOnly */, input /* clearBuffer */, buffer, &byteBuffer);
558 env, true /* readOnly */, true /* clearBuffer */, imageData, &infoBuffer);
560 env->DeleteLocalRef(byteBuffer);
569 env, env->FindClass("android/graphics/Rect"));
572 jmethodID rectConstructID = env->GetMethodID(
575 cropRect = env->NewObject(
580 env, env->FindClass("android/media/MediaCodec$MediaImage"));
583 jmethodID imageConstructID = env->GetMethodID(imageClazz.get(), "<init>",
586 *buf = env->NewObject(imageClazz.get(), imageConstructID,
593 if (env->ExceptionCheck()) {
594 env->ExceptionDescribe();
595 env->ExceptionClear();
600 env->DeleteLocalRef(cropRect);
604 env->DeleteLocalRef(byteBuffer);
607 env->DeleteLocalRef(infoBuffer);
613 status_t JMediaCodec::getName(JNIEnv *env, jstring *nameStr) const {
622 *nameStr = env->NewStringUTF(name.c_str());
644 JNIEnv *env, status_t err, int32_t actionCode, const char *msg = NULL) {
646 env, env->FindClass("android/media/MediaCodec$CodecException"));
649 const jmethodID ctor = env->GetMethodID(clazz.get(), "<init>", "(IILjava/lang/String;)V");
653 env, env->NewStringUTF(msg != NULL ? msg : String8::format("Error %#x", err)));
680 return (jthrowable)env->NewObject(clazz.get(), ctor, err, actionCode, msgObj.get());
687 JNIEnv *env = AndroidRuntime::getJNIEnv();
709 env, env->FindClass("android/media/MediaCodec$BufferInfo"));
710 jmethodID ctor = env->GetMethodID(clazz.get(), "<init>", "()V");
711 jmethodID method = env->GetMethodID(clazz.get(), "set", "(IIJI)V");
713 obj = env->NewObject(clazz.get(), ctor);
716 if (env->ExceptionCheck()) {
718 env->ExceptionClear();
720 jniThrowException(env, "java/lang/IllegalStateException", NULL);
724 env->CallVoidMethod(obj, method, (jint)offset, (jint)size, timeUs, flags);
735 obj = (jobject)createCodecException(env, err, actionCode);
738 if (env->ExceptionCheck()) {
740 env->ExceptionClear();
742 jniThrowException(env, "java/lang/IllegalStateException", NULL);
754 if (OK != ConvertMessageToMap(env, format, &obj)) {
755 jniThrowException(env, "java/lang/IllegalStateException", NULL);
766 env->CallVoidMethod(
774 env->DeleteLocalRef(obj);
780 JNIEnv *env = AndroidRuntime::getJNIEnv();
785 status_t err = ConvertMessageToMap(env, data, &obj);
787 jniThrowException(env, "java/lang/IllegalStateException", NULL);
791 env->CallVoidMethod(
795 env->DeleteLocalRef(obj);
822 JNIEnv *env, jobject thiz, const sp<JMediaCodec> &codec) {
823 sp<JMediaCodec> old = (JMediaCodec *)env->GetLongField(thiz, gFields.context);
836 env->SetLongField(thiz, gFields.context, (jlong)codec.get());
841 static sp<JMediaCodec> getMediaCodec(JNIEnv *env, jobject thiz) {
842 return (JMediaCodec *)env->GetLongField(thiz, gFields.context);
845 static void android_media_MediaCodec_release(JNIEnv *env, jobject thiz) {
846 setMediaCodec(env, thiz, NULL);
849 static void throwCodecException(JNIEnv *env, status_t err, int32_t actionCode, const char *msg) {
850 jthrowable exception = createCodecException(env, err, actionCode, msg);
851 env->Throw(exception);
854 static void throwCryptoException(JNIEnv *env, status_t err, const char *msg) {
856 env, env->FindClass("android/media/MediaCodec$CryptoException"));
860 env->GetMethodID(clazz.get(), "<init>", "(ILjava/lang/String;)V");
895 jstring msgObj = env->NewStringUTF(msg != NULL ? msg : defaultMsg);
898 (jthrowable)env->NewObject(clazz.get(), constructID, err, msgObj);
900 env->Throw(exception);
904 JNIEnv *env, status_t err, int32_t actionCode = ACTION_CODE_FATAL,
920 jniThrowException(env, "java/lang/IllegalStateException", msg);
924 jniThrowException(env, "java/lang/IllegalArgumentException", msg);
929 throwCryptoException(env, err, msg);
932 throwCodecException(env, err, actionCode, msg);
938 JNIEnv *env,
941 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
944 throwExceptionAsNecessary(env, INVALID_OPERATION);
950 throwExceptionAsNecessary(env, err);
954 JNIEnv *env,
957 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
960 throwExceptionAsNecessary(env, INVALID_OPERATION);
966 throwExceptionAsNecessary(env, err);
970 JNIEnv *env,
977 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
980 throwExceptionAsNecessary(env, INVALID_OPERATION);
985 status_t err = ConvertKeyValueArraysToMessage(env, keys, values, &format);
988 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
994 sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
999 env,
1008 crypto = JCrypto::GetCrypto(env, jcrypto);
1013 sp<IBinder> binder = ibinderForJavaObject(env, descramblerBinderObj);
1019 throwExceptionAsNecessary(env, err);
1023 JNIEnv *env,
1026 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1029 throwExceptionAsNecessary(env, INVALID_OPERATION);
1035 sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
1040 env,
1048 throwExceptionAsNecessary(env, err);
1052 JNIEnv* env, jobject object) {
1055 jobject lock = env->GetObjectField(
1057 if (env->MonitorEnter(lock) == JNI_OK) {
1059 env->GetLongField(object,
1061 env->MonitorExit(lock);
1063 env->DeleteLocalRef(lock);
1069 JNIEnv* env, jclass /* clazz */) {
1084 jobject object = env->NewObject(
1089 if (env->ExceptionCheck()) {
1091 env->ExceptionClear();
1096 jobject lock = env->GetObjectField(
1098 if (env->MonitorEnter(lock) == JNI_OK) {
1099 env->CallVoidMethod(
1103 env->SetLongField(
1107 env->MonitorExit(lock);
1109 env->DeleteLocalRef(object);
1112 env->DeleteLocalRef(lock);
1123 JNIEnv* env, jclass /* clazz */, jobject object) {
1126 jobject lock = env->GetObjectField(
1128 if (env->MonitorEnter(lock) == JNI_OK) {
1130 env->GetLongField(
1132 env->SetLongField(
1136 env->MonitorExit(lock);
1138 env->DeleteLocalRef(lock);
1147 JNIEnv* env, jobject thiz, jobject object) {
1150 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1152 throwExceptionAsNecessary(env, INVALID_OPERATION);
1157 android_media_MediaCodec_getPersistentInputSurface(env, object);
1161 throwExceptionAsNecessary(env, err);
1165 static jobject android_media_MediaCodec_createInputSurface(JNIEnv* env,
1169 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1171 throwExceptionAsNecessary(env, INVALID_OPERATION);
1179 throwExceptionAsNecessary(env, err);
1184 return android_view_Surface_createFromIGraphicBufferProducer(env,
1188 static void android_media_MediaCodec_start(JNIEnv *env, jobject thiz) {
1191 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1194 throwExceptionAsNecessary(env, INVALID_OPERATION);
1200 throwExceptionAsNecessary(env, err, ACTION_CODE_FATAL, "start failed");
1203 static void android_media_MediaCodec_stop(JNIEnv *env, jobject thiz) {
1206 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1209 throwExceptionAsNecessary(env, INVALID_OPERATION);
1215 throwExceptionAsNecessary(env, err);
1218 static void android_media_MediaCodec_reset(JNIEnv *env, jobject thiz) {
1221 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1224 throwExceptionAsNecessary(env, INVALID_OPERATION);
1237 throwExceptionAsNecessary(env, err);
1240 static void android_media_MediaCodec_flush(JNIEnv *env, jobject thiz) {
1243 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1246 throwExceptionAsNecessary(env, INVALID_OPERATION);
1252 throwExceptionAsNecessary(env, err);
1256 JNIEnv *env,
1265 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1268 throwExceptionAsNecessary(env, INVALID_OPERATION);
1278 env, err, ACTION_CODE_FATAL, errorDetailMsg.empty() ? NULL : errorDetailMsg.c_str());
1282 JNIEnv *env,
1291 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1294 throwExceptionAsNecessary(env, INVALID_OPERATION);
1299 env->GetIntField(cryptoInfoObj, gFields.cryptoInfoNumSubSamplesID);
1302 (jintArray)env->GetObjectField(
1306 (jintArray)env->GetObjectField(
1310 (jbyteArray)env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoKeyID);
1313 (jbyteArray)env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoIVID);
1315 jint jmode = env->GetIntField(cryptoInfoObj, gFields.cryptoInfoModeID);
1324 throwExceptionAsNecessary(env, INVALID_OPERATION);
1328 jobject patternObj = env->GetObjectField(cryptoInfoObj, gFields.cryptoInfoPatternID);
1335 pattern.mEncryptBlocks = env->GetIntField(patternObj, gFields.patternEncryptBlocksID);
1336 pattern.mSkipBlocks = env->GetIntField(patternObj, gFields.patternSkipBlocksID);
1351 && env->GetArrayLength(numBytesOfEncryptedDataObj) < numSubSamples) {
1354 && env->GetArrayLength(numBytesOfClearDataObj) < numSubSamples) {
1366 : env->GetIntArrayElements(numBytesOfClearDataObj, &isCopy);
1371 : env->GetIntArrayElements(numBytesOfEncryptedDataObj, &isCopy);
1385 env->ReleaseIntArrayElements(
1391 env->ReleaseIntArrayElements(
1398 if (env->GetArrayLength(keyObj) != 16) {
1402 key = env->GetByteArrayElements(keyObj, &isCopy);
1407 if (env->GetArrayLength(ivObj) != 16) {
1411 iv = env->GetByteArrayElements(ivObj, &isCopy);
1430 env->ReleaseByteArrayElements(ivObj, iv, 0);
1435 env->ReleaseByteArrayElements(keyObj, key, 0);
1443 env, err, ACTION_CODE_FATAL, errorDetailMsg.empty() ? NULL : errorDetailMsg.c_str());
1447 JNIEnv *env, jobject thiz, jlong timeoutUs) {
1450 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1453 throwExceptionAsNecessary(env, INVALID_OPERATION);
1464 return throwExceptionAsNecessary(env, err);
1468 JNIEnv *env, jobject thiz, jobject bufferInfo, jlong timeoutUs) {
1471 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1474 throwExceptionAsNecessary(env, INVALID_OPERATION);
1480 env, bufferInfo, &index, timeoutUs);
1486 return throwExceptionAsNecessary(env, err);
1490 JNIEnv *env, jobject thiz,
1494 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1497 throwExceptionAsNecessary(env, INVALID_OPERATION);
1503 throwExceptionAsNecessary(env, err);
1506 static void android_media_MediaCodec_signalEndOfInputStream(JNIEnv* env,
1510 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1512 throwExceptionAsNecessary(env, INVALID_OPERATION);
1518 throwExceptionAsNecessary(env, err);
1522 JNIEnv *env, jobject thiz, jboolean input) {
1525 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1528 throwExceptionAsNecessary(env, INVALID_OPERATION);
1533 status_t err = codec->getFormat(env, input, &format);
1539 throwExceptionAsNecessary(env, err);
1545 JNIEnv *env, jobject thiz, jint index) {
1548 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1551 throwExceptionAsNecessary(env, INVALID_OPERATION);
1556 status_t err = codec->getOutputFormat(env, index, &format);
1562 throwExceptionAsNecessary(env, err);
1568 JNIEnv *env, jobject thiz, jboolean input) {
1571 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1574 throwExceptionAsNecessary(env, INVALID_OPERATION);
1579 status_t err = codec->getBuffers(env, input, &buffers);
1587 throwExceptionAsNecessary(env, err);
1594 JNIEnv *env, jobject thiz, jboolean input, jint index) {
1597 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1600 throwExceptionAsNecessary(env, INVALID_OPERATION);
1605 status_t err = codec->getBuffer(env, input, index, &buffer);
1613 throwExceptionAsNecessary(env, err);
1620 JNIEnv *env, jobject thiz, jboolean input, jint index) {
1623 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1626 throwExceptionAsNecessary(env, INVALID_OPERATION);
1631 status_t err = codec->getImage(env, input, index, &image);
1639 throwExceptionAsNecessary(env, err);
1646 JNIEnv *env, jobject thiz) {
1649 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1652 throwExceptionAsNecessary(env, INVALID_OPERATION);
1657 status_t err = codec->getName(env, &name);
1663 throwExceptionAsNecessary(env, err);
1669 android_media_MediaCodec_native_getMetrics(JNIEnv *env, jobject thiz)
1673 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1675 jniThrowException(env, "java/lang/IllegalStateException", NULL);
1682 status_t err = codec->getMetrics(env, item);
1688 jobject mybundle = MediaMetricsJNI::writeMetricsToBundle(env, item, NULL);
1698 JNIEnv *env, jobject thiz, jobjectArray keys, jobjectArray vals) {
1701 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1704 throwExceptionAsNecessary(env, INVALID_OPERATION);
1709 status_t err = ConvertKeyValueArraysToMessage(env, keys, vals, ¶ms);
1715 throwExceptionAsNecessary(env, err);
1719 JNIEnv *env, jobject thiz, jint mode) {
1720 sp<JMediaCodec> codec = getMediaCodec(env, thiz);
1723 throwExceptionAsNecessary(env, INVALID_OPERATION);
1729 jniThrowException(env, "java/lang/InvalidArgumentException", NULL);
1736 static void android_media_MediaCodec_native_init(JNIEnv *env) {
1738 env, env->FindClass("android/media/MediaCodec"));
1741 gFields.context = env->GetFieldID(clazz.get(), "mNativeContext", "J");
1745 env->GetMethodID(
1751 field = env->GetStaticFieldID(clazz.get(), "CRYPTO_MODE_UNENCRYPTED", "I");
1754 env->GetStaticIntField(clazz.get(), field);
1756 field = env->GetStaticFieldID(clazz.get(), "CRYPTO_MODE_AES_CTR", "I");
1759 env->GetStaticIntField(clazz.get(), field);
1761 field = env->GetStaticFieldID(clazz.get(), "CRYPTO_MODE_AES_CBC", "I");
1764 env->GetStaticIntField(clazz.get(), field);
1766 clazz.reset(env->FindClass("android/media/MediaCodec$CryptoInfo"));
1770 env->GetFieldID(clazz.get(), "numSubSamples", "I");
1774 env->GetFieldID(clazz.get(), "numBytesOfClearData", "[I");
1778 env->GetFieldID(clazz.get(), "numBytesOfEncryptedData", "[I");
1781 gFields.cryptoInfoKeyID = env->GetFieldID(clazz.get(), "key", "[B");
1784 gFields.cryptoInfoIVID = env->GetFieldID(clazz.get(), "iv", "[B");
1787 gFields.cryptoInfoModeID = env->GetFieldID(clazz.get(), "mode", "I");
1790 gFields.cryptoInfoPatternID = env->GetFieldID(clazz.get(), "pattern",
1794 clazz.reset(env->FindClass("android/media/MediaCodec$CryptoInfo$Pattern"));
1797 gFields.patternEncryptBlocksID = env->GetFieldID(clazz.get(), "mEncryptBlocks", "I");
1800 gFields.patternSkipBlocksID = env->GetFieldID(clazz.get(), "mSkipBlocks", "I");
1803 clazz.reset(env->FindClass("android/media/MediaCodec$CryptoException"));
1806 field = env->GetStaticFieldID(clazz.get(), "ERROR_NO_KEY", "I");
1809 env->GetStaticIntField(clazz.get(), field);
1811 field = env->GetStaticFieldID(clazz.get(), "ERROR_KEY_EXPIRED", "I");
1814 env->GetStaticIntField(clazz.get(), field);
1816 field = env->GetStaticFieldID(clazz.get(), "ERROR_RESOURCE_BUSY", "I");
1819 env->GetStaticIntField(clazz.get(), field);
1821 field = env->GetStaticFieldID(clazz.get(), "ERROR_INSUFFICIENT_OUTPUT_PROTECTION", "I");
1824 env->GetStaticIntField(clazz.get(), field);
1826 field = env->GetStaticFieldID(clazz.get(), "ERROR_SESSION_NOT_OPENED", "I");
1829 env->GetStaticIntField(clazz.get(), field);
1831 field = env->GetStaticFieldID(clazz.get(), "ERROR_UNSUPPORTED_OPERATION", "I");
1834 env->GetStaticIntField(clazz.get(), field);
1836 clazz.reset(env->FindClass("android/media/MediaCodec$CodecException"));
1838 field = env->GetStaticFieldID(clazz.get(), "ACTION_TRANSIENT", "I");
1841 env->GetStaticIntField(clazz.get(), field);
1843 field = env->GetStaticFieldID(clazz.get(), "ACTION_RECOVERABLE", "I");
1846 env->GetStaticIntField(clazz.get(), field);
1848 field = env->GetStaticFieldID(clazz.get(), "ERROR_INSUFFICIENT_RESOURCE", "I");
1851 env->GetStaticIntField(clazz.get(), field);
1853 field = env->GetStaticFieldID(clazz.get(), "ERROR_RECLAIMED", "I");
1856 env->GetStaticIntField(clazz.get(), field);
1858 clazz.reset(env->FindClass("android/view/Surface"));
1861 field = env->GetFieldID(clazz.get(), "mLock", "Ljava/lang/Object;");
1865 jmethodID method = env->GetMethodID(clazz.get(), "setNativeObjectLocked", "(J)V");
1869 clazz.reset(env->FindClass("android/media/MediaCodec$PersistentSurface"));
1871 gPersistentSurfaceClassInfo.clazz = (jclass)env->NewGlobalRef(clazz.get());
1873 method = env->GetMethodID(clazz.get(), "<init>", "()V");
1877 field = env->GetFieldID(clazz.get(), "mPersistentObject", "J");
1883 JNIEnv *env, jobject thiz,
1886 jniThrowException(env, "java/lang/NullPointerException", NULL);
1890 const char *tmp = env->GetStringUTFChars(name, NULL);
1896 sp<JMediaCodec> codec = new JMediaCodec(env, thiz, tmp, nameIsType, encoder);
1901 jniThrowException(env, "java/lang/IllegalArgumentException",
1903 env->ReleaseStringUTFChars(name, tmp);
1906 throwCodecException(env, err, ACTION_CODE_TRANSIENT,
1908 env->ReleaseStringUTFChars(name, tmp);
1912 jniThrowException(env, "java/io/IOException",
1914 env->ReleaseStringUTFChars(name, tmp);
1918 env->ReleaseStringUTFChars(name, tmp);
1922 setMediaCodec(env,thiz, codec);
1926 JNIEnv *env, jobject thiz) {
1927 android_media_MediaCodec_release(env, thiz);
2023 int register_android_media_MediaCodec(JNIEnv *env) {
2024 return AndroidRuntime::registerNativeMethods(env,