/*
|
mediastreamer2 android_mediacodec.cpp
|
Copyright (C) 2015 Belledonne Communications SARL
|
|
This program is free software; you can redistribute it and/or
|
modify it under the terms of the GNU General Public License
|
as published by the Free Software Foundation; either version 2
|
of the License, or (at your option) any later version.
|
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
*/
|
|
//#include "mediastreamer2/mscommon.h"
|
// https://github.com/BelledonneCommunications/ortp/blob/100146d7c09aea0bddcc6a10926f1ee528d42738/include/ortp/port.h
|
#define ms_new0(type,count) (type*)malloc(sizeof(type)*(count))
|
#define ms_free(ptr) free(ptr)
|
|
static const int TRUE = 1;
|
static const int FALSE = 0;
|
|
#include "mediastreamer2/msjava.h"
|
|
#include <media/NdkMediaCodec.h>
|
#include <media/NdkMediaFormat.h>
|
#include "android_mediacodec.h"
|
|
#include "../../logger.h"
|
|
////////////////////////////////////////////////////
|
// //
|
// MEDIA CODEC //
|
// //
|
////////////////////////////////////////////////////
|
|
struct AMediaCodec {
|
jobject jcodec;
|
// mediaBufferInfo Class
|
jmethodID _init_mediaBufferInfoClass;
|
// MediaCodec Class
|
jmethodID configure;
|
jmethodID reset;
|
jmethodID start;
|
jmethodID release;
|
jmethodID flush;
|
jmethodID stop;
|
jmethodID getInputBuffer;
|
jmethodID getOutputBuffer;
|
jmethodID dequeueInputBuffer;
|
jmethodID queueInputBuffer;
|
jmethodID dequeueOutputBuffer;
|
jmethodID getOutputFormat;
|
jmethodID getOutputImageMethod;
|
jmethodID getInputImageMethod;
|
jmethodID releaseOutputBuffer;
|
jmethodID setParameters;
|
// image Class
|
jmethodID getFormatMethod;
|
jmethodID getWidthMethod;
|
jmethodID getHeightMethod;
|
jmethodID getTimestrampMethod;
|
jmethodID getPlanesMethod;
|
jmethodID getCropRectMethod;
|
// plane Class
|
jmethodID getPixelStrideMethod;
|
jmethodID getRowStrideMethod;
|
jmethodID getBufferMethod;
|
// Bundle Class
|
jmethodID _init_BundleClass;
|
jmethodID putIntId;
|
// rect Class
|
jfieldID bottomField;
|
jfieldID leftField;
|
jfieldID rightField;
|
jfieldID topField;
|
// mediaBufferInfo Class
|
jfieldID size;
|
jfieldID flags;
|
jfieldID offset;
|
};
|
|
struct AMediaFormat {
|
jobject jformat;
|
// mediaFormat Class
|
jmethodID setInteger;
|
jmethodID getInteger;
|
jmethodID setString;
|
};
|
|
int handle_java_exception() {
|
JNIEnv *env = ms_get_jni_env();
|
if (env->ExceptionCheck()) {
|
env->ExceptionDescribe();
|
env->ExceptionClear();
|
return -1;
|
}
|
return 0;
|
}
|
|
static bool _loadClass(JNIEnv *env, const char *className, jclass *_class) {
|
*_class = env->FindClass(className);
|
if(handle_java_exception() == -1 || *_class == NULL) {
|
LOGP(ERROR, "Could not load Java class [%s]", className);
|
return false;
|
}
|
return true;
|
}
|
|
static bool _getMethodID(JNIEnv *env, jclass _class, const char *name, const char *sig, jmethodID *method) {
|
*method = env->GetMethodID(_class, name, sig);
|
if(handle_java_exception() == -1 || *method == NULL) {
|
LOGP(ERROR, "Could not get method %s[%s]", name, sig);
|
return false;
|
}
|
return true;
|
}
|
|
static bool _getStaticMethodID(JNIEnv *env, jclass _class, const char *name, const char *sig, jmethodID *method) {
|
*method = env->GetStaticMethodID(_class, name, sig);
|
if(handle_java_exception() == -1 || *method == NULL) {
|
LOGP(ERROR, "Could not get static method %s[%s]", name, sig);
|
return false;
|
}
|
return true;
|
}
|
|
static bool _getFieldID(JNIEnv *env, jclass _class, const char *name, const char *sig, jfieldID *field) {
|
*field = env->GetFieldID(_class, name, sig);
|
if(handle_java_exception() == -1 || *field == NULL) {
|
LOGP(ERROR, "Could not get field %s[%s]", name, sig);
|
return false;
|
}
|
return true;
|
}
|
|
bool AMediaCodec_loadMethodID(const char *createName, AMediaCodec *codec, const char *mime_type) {
|
JNIEnv *env = ms_get_jni_env();
|
jobject jcodec = NULL;
|
jclass mediaCodecClass = NULL, imageClass = NULL, planeClass = NULL, rectClass = NULL, mediaBufferInfoClass = NULL, BundleClass = NULL;
|
jmethodID createMethod = NULL;
|
jstring msg = NULL;
|
bool success = true;
|
|
success &= _loadClass(env, "android/media/MediaCodec", &mediaCodecClass);
|
success &= _loadClass(env, "android/media/Image", &imageClass);
|
success &= _loadClass(env, "android/media/Image$Plane", &planeClass);
|
success &= _loadClass(env, "android/graphics/Rect", &rectClass);
|
success &= _loadClass(env, "android/media/MediaCodec$BufferInfo", &mediaBufferInfoClass);
|
success &= _loadClass(env, "android/os/Bundle", &BundleClass);
|
if (!success) {
|
LOGP(ERROR, "%s(): one class could not be found", __FUNCTION__);
|
goto error;
|
}
|
|
success &= _getStaticMethodID(env, mediaCodecClass, createName, "(Ljava/lang/String;)Landroid/media/MediaCodec;", &createMethod);
|
success &= _getMethodID(env, mediaCodecClass, "configure", "(Landroid/media/MediaFormat;Landroid/view/Surface;Landroid/media/MediaCrypto;I)V", &(codec->configure));
|
success &= _getMethodID(env, mediaCodecClass, "reset", "()V", &(codec->reset));
|
success &= _getMethodID(env, mediaCodecClass, "start", "()V", &(codec->start));
|
success &= _getMethodID(env, mediaCodecClass, "release", "()V", &(codec->release));
|
success &= _getMethodID(env, mediaCodecClass, "flush", "()V", &(codec->flush));
|
success &= _getMethodID(env, mediaCodecClass, "stop", "()V", &(codec->stop));
|
success &= _getMethodID(env, mediaCodecClass, "getInputBuffer", "(I)Ljava/nio/ByteBuffer;", &(codec->getInputBuffer));
|
success &= _getMethodID(env, mediaCodecClass, "getOutputBuffer","(I)Ljava/nio/ByteBuffer;", &(codec->getOutputBuffer));
|
success &= _getMethodID(env, mediaCodecClass, "dequeueInputBuffer", "(J)I", &(codec->dequeueInputBuffer));
|
success &= _getMethodID(env, mediaCodecClass, "queueInputBuffer", "(IIIJI)V", &(codec->queueInputBuffer));
|
success &= _getMethodID(env, mediaCodecClass, "dequeueOutputBuffer", "(Landroid/media/MediaCodec$BufferInfo;J)I", &(codec->dequeueOutputBuffer));
|
success &= _getMethodID(env, mediaCodecClass, "getOutputFormat", "()Landroid/media/MediaFormat;", &(codec->getOutputFormat));
|
success &= _getMethodID(env, mediaCodecClass, "getInputImage", "(I)Landroid/media/Image;", &(codec->getInputImageMethod));
|
success &= _getMethodID(env, mediaCodecClass, "getOutputImage", "(I)Landroid/media/Image;", &(codec->getOutputImageMethod));
|
success &= _getMethodID(env, mediaCodecClass, "releaseOutputBuffer", "(IZ)V", &(codec->releaseOutputBuffer));
|
success &= _getMethodID(env, mediaCodecClass, "setParameters", "(Landroid/os/Bundle;)V", &(codec->setParameters));
|
success &= _getMethodID(env, imageClass, "getFormat", "()I", &(codec->getFormatMethod));
|
success &= _getMethodID(env, imageClass, "getWidth", "()I", &(codec->getWidthMethod));
|
success &= _getMethodID(env, imageClass, "getHeight", "()I", &(codec->getHeightMethod));
|
success &= _getMethodID(env, imageClass, "getTimestamp", "()J", &(codec->getTimestrampMethod));
|
success &= _getMethodID(env, imageClass, "getPlanes", "()[Landroid/media/Image$Plane;", &(codec->getPlanesMethod));
|
success &= _getMethodID(env, imageClass, "getCropRect", "()Landroid/graphics/Rect;", &(codec->getCropRectMethod));
|
success &= _getMethodID(env, planeClass, "getPixelStride", "()I", &(codec->getPixelStrideMethod));
|
success &= _getMethodID(env, planeClass, "getRowStride", "()I", &(codec->getRowStrideMethod));
|
success &= _getMethodID(env, planeClass, "getBuffer", "()Ljava/nio/ByteBuffer;", &(codec->getBufferMethod));
|
success &= _getMethodID(env, mediaBufferInfoClass, "<init>", "()V", &(codec->_init_mediaBufferInfoClass));
|
success &= _getMethodID(env, BundleClass,"<init>","()V", &(codec->_init_BundleClass));
|
success &= _getMethodID(env, BundleClass,"putInt","(Ljava/lang/String;I)V", &(codec->putIntId));
|
success &= _getFieldID(env, rectClass, "bottom", "I", &(codec->bottomField));
|
success &= _getFieldID(env, rectClass, "left", "I", &(codec->leftField));
|
success &= _getFieldID(env, rectClass, "right", "I", &(codec->rightField));
|
success &= _getFieldID(env, rectClass, "top", "I", &(codec->topField));
|
success &= _getFieldID(env, mediaBufferInfoClass, "size" , "I", &(codec->size));
|
success &= _getFieldID(env, mediaBufferInfoClass, "flags" , "I", &(codec->flags));
|
success &= _getFieldID(env, mediaBufferInfoClass, "offset" , "I", &(codec->offset));
|
if(!success) {
|
LOGP(ERROR, "%s(): one method or field could not be found", __FUNCTION__);
|
goto error;
|
}
|
|
msg = env->NewStringUTF(mime_type);
|
jcodec = env->CallStaticObjectMethod(mediaCodecClass, createMethod, msg);
|
handle_java_exception();
|
if (!jcodec) {
|
LOGP(ERROR, "Failed to create codec !");
|
goto error;
|
}
|
|
codec->jcodec = env->NewGlobalRef(jcodec);
|
LOGP(INFO, "Codec %s successfully created.", mime_type);
|
|
env->DeleteLocalRef(mediaCodecClass);
|
env->DeleteLocalRef(jcodec);
|
env->DeleteLocalRef(imageClass);
|
env->DeleteLocalRef(planeClass);
|
env->DeleteLocalRef(rectClass);
|
env->DeleteLocalRef(BundleClass);
|
env->DeleteLocalRef(msg);
|
return true;
|
|
error:
|
if (mediaCodecClass) env->DeleteLocalRef(mediaCodecClass);
|
if (jcodec) env->DeleteLocalRef(jcodec);
|
if (imageClass) env->DeleteLocalRef(imageClass);
|
if (planeClass) env->DeleteLocalRef(planeClass);
|
if (rectClass) env->DeleteLocalRef(rectClass);
|
if (BundleClass) env->DeleteLocalRef(BundleClass);
|
if (msg) env->DeleteLocalRef(msg);
|
return false;
|
}
|
|
AMediaCodec * AMediaCodec_createDecoderByType(const char *mime_type) {
|
AMediaCodec *codec = ms_new0(AMediaCodec, 1);
|
if (!AMediaCodec_loadMethodID("createDecoderByType", codec, mime_type)) {
|
ms_free(codec);
|
codec = NULL;
|
}
|
return codec;
|
}
|
|
AMediaCodec* AMediaCodec_createEncoderByType(const char *mime_type) {
|
AMediaCodec *codec = ms_new0(AMediaCodec, 1);
|
if (!AMediaCodec_loadMethodID("createEncoderByType", codec, mime_type)) {
|
ms_free(codec);
|
codec = NULL;
|
}
|
return codec;
|
}
|
|
media_status_t AMediaCodec_configure(AMediaCodec *codec, const AMediaFormat* format, ANativeWindow* surface, AMediaCrypto *crypto, uint32_t flags) {
|
JNIEnv *env = ms_get_jni_env();
|
|
//env->CallVoidMethod(codec->jcodec, codec->configure, format->jformat, NULL, NULL, flags);
|
env->CallVoidMethod(codec->jcodec, codec->configure, format->jformat, NULL, NULL, flags);
|
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_BASE : AMEDIA_OK;
|
}
|
|
media_status_t AMediaCodec_delete(AMediaCodec *codec) {
|
JNIEnv *env = ms_get_jni_env();
|
|
env->CallVoidMethod(codec->jcodec, codec->release);
|
env->DeleteGlobalRef(codec->jcodec);
|
ms_free(codec);
|
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_BASE : AMEDIA_OK;
|
}
|
|
media_status_t AMediaCodec_start(AMediaCodec *codec) {
|
JNIEnv *env = ms_get_jni_env();
|
|
env->CallVoidMethod(codec->jcodec, codec->start);
|
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_BASE : AMEDIA_OK;
|
}
|
|
media_status_t AMediaCodec_flush(AMediaCodec *codec) {
|
JNIEnv *env = ms_get_jni_env();
|
|
env->CallVoidMethod(codec->jcodec, codec->flush);
|
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_BASE : AMEDIA_OK;
|
}
|
|
media_status_t AMediaCodec_stop(AMediaCodec *codec) {
|
JNIEnv *env = ms_get_jni_env();
|
|
env->CallVoidMethod(codec->jcodec, codec->stop);
|
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_BASE : AMEDIA_OK;
|
}
|
|
|
uint8_t* AMediaCodec_getInputBuffer(AMediaCodec *codec, size_t idx, size_t *out_size) {
|
JNIEnv *env = ms_get_jni_env();
|
jobject jbuf = NULL;
|
uint8_t *buf = NULL;
|
|
jbuf = env->CallObjectMethod(codec->jcodec, codec->getInputBuffer, (jint) idx);
|
if(jbuf != NULL){
|
jlong capacity = env->GetDirectBufferCapacity(jbuf);
|
*out_size = (size_t) capacity;
|
buf = (uint8_t *) env->GetDirectBufferAddress(jbuf);
|
env->DeleteLocalRef(jbuf);
|
} else {
|
LOGP(ERROR, "getInputBuffer() failed !");
|
env->ExceptionClear();
|
}
|
handle_java_exception();
|
return buf;
|
}
|
|
uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec *codec, size_t idx, size_t *out_size) {
|
JNIEnv *env = ms_get_jni_env();
|
jobject jbuf = NULL;
|
uint8_t *buf = NULL;
|
jlong capacity;
|
|
jbuf = env->CallObjectMethod(codec->jcodec, codec->getOutputBuffer, (jint) idx);
|
if (jbuf != NULL){
|
buf = (uint8_t *) env->GetDirectBufferAddress(jbuf);
|
capacity = env->GetDirectBufferCapacity(jbuf);
|
*out_size = (size_t) capacity;
|
env->DeleteLocalRef(jbuf);
|
} else {
|
LOGP(ERROR, "getOutputBuffer() failed !");
|
env->ExceptionClear();
|
}
|
handle_java_exception();
|
return buf;
|
}
|
|
ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec *codec, int64_t timeoutUs) {
|
JNIEnv *env = ms_get_jni_env();
|
jint jindex = -1;
|
|
jindex = env->CallIntMethod(codec->jcodec, codec->dequeueInputBuffer, timeoutUs);
|
|
/*return value to notify the exception*/
|
/*otherwise, if -1 is returned as index, it just means that no buffer are available at this time (not an error)*/
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_UNKNOWN : (ssize_t) jindex;
|
}
|
|
media_status_t AMediaCodec_queueInputBuffer(AMediaCodec *codec, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags) {
|
JNIEnv *env = ms_get_jni_env();
|
|
env->CallVoidMethod(codec->jcodec, codec->queueInputBuffer, idx, offset, size, time, flags);
|
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_BASE : AMEDIA_OK;
|
}
|
|
ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec *codec, AMediaCodecBufferInfo *info, int64_t timeoutUs) {
|
JNIEnv *env = ms_get_jni_env();
|
jint jindex = -1;
|
jobject jinfo = NULL;
|
jclass mediaBufferInfoClass;
|
|
/* We can't stock jclass information due to JNIEnv difference between different threads */
|
if(!_loadClass(env, "android/media/MediaCodec$BufferInfo", &mediaBufferInfoClass)) {
|
LOGP(ERROR, "%s(): one class could not be found", __FUNCTION__);
|
env->ExceptionClear();
|
return AMEDIA_ERROR_UNKNOWN;
|
}
|
|
jinfo = env->NewObject(mediaBufferInfoClass, codec->_init_mediaBufferInfoClass);
|
|
jindex = env->CallIntMethod(codec->jcodec, codec->dequeueOutputBuffer , jinfo, timeoutUs);
|
if (env->ExceptionCheck()) {
|
env->ExceptionDescribe();
|
env->ExceptionClear();
|
LOGP(ERROR, "Exception");
|
jindex = AMEDIA_ERROR_UNKNOWN; /*return value to notify the exception*/
|
/*otherwise, if -1 is returned as index, it just means that no buffer are available at this time (not an error)*/
|
}
|
|
if (jindex >= 0) {
|
info->size = env->GetIntField(jinfo, codec->size);
|
info->offset = env->GetIntField(jinfo, codec->offset);
|
info->flags = env->GetIntField(jinfo, codec->flags);
|
}
|
|
env->DeleteLocalRef(mediaBufferInfoClass);
|
env->DeleteLocalRef(jinfo);
|
return (ssize_t) jindex;
|
}
|
|
AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec *codec) {
|
AMediaFormat *format = AMediaFormat_new();
|
JNIEnv *env = ms_get_jni_env();
|
jobject jformat = NULL;
|
|
jformat = env->CallObjectMethod(codec->jcodec, codec->getOutputFormat);
|
handle_java_exception();
|
if (!jformat) {
|
LOGP(ERROR, "Failed to create format !");
|
return NULL;
|
}
|
|
format->jformat = env->NewGlobalRef(jformat);
|
env->DeleteLocalRef(jformat);
|
return format;
|
}
|
|
media_status_t AMediaCodec_releaseOutputBuffer(AMediaCodec *codec, size_t idx, bool render) {
|
JNIEnv *env = ms_get_jni_env();
|
env->CallVoidMethod(codec->jcodec, codec->releaseOutputBuffer, (int)idx, FALSE);
|
return (handle_java_exception() == -1) ? AMEDIA_ERROR_BASE : AMEDIA_OK;
|
}
|
|
void AMediaCodec_reset(AMediaCodec *codec) {
|
JNIEnv *env = ms_get_jni_env();
|
env->CallVoidMethod(codec->jcodec, codec->reset);
|
handle_java_exception();
|
}
|
|
void AMediaCodec_setParams(AMediaCodec *codec, const char *params) {
|
JNIEnv *env = ms_get_jni_env();
|
jobject jbundle = NULL;
|
jclass BundleClass = NULL;
|
|
/* We can't stock jclass information due to JNIEnv difference between different threads */
|
if (!_loadClass(env, "android/os/Bundle", &BundleClass)) {
|
LOGP(ERROR, "%s(): one class could not be found", __FUNCTION__);
|
handle_java_exception();
|
return;
|
}
|
|
jstring msg = env->NewStringUTF(params);
|
jbundle = env->NewObject(BundleClass, codec->_init_BundleClass);
|
env->CallVoidMethod(jbundle, codec->putIntId, msg, 0);
|
handle_java_exception();
|
env->DeleteLocalRef(msg);
|
|
env->CallVoidMethod(codec->jcodec, codec->setParameters, jbundle);
|
handle_java_exception();
|
env->DeleteLocalRef(jbundle);
|
env->DeleteLocalRef(BundleClass);
|
}
|
|
static bool _getImage(JNIEnv *env, AMediaCodec *codec, const bool isInput, int index, AMediaImage *image) {
|
jobject jimage = NULL, jrect = NULL;
|
jobjectArray jplanes = NULL;
|
int bottom, left, right, top;
|
bool success = TRUE;
|
|
jimage = (isInput) ?
|
env->CallObjectMethod(codec->jcodec, codec->getInputImageMethod, index):
|
env->CallObjectMethod(codec->jcodec, codec->getOutputImageMethod, index);
|
|
if(handle_java_exception() == -1 || jimage == NULL) {
|
LOGP(ERROR, "%s(): could not get the %s image with index [%d]", __FUNCTION__, (isInput) ? "input" : "output", index);
|
success = FALSE;
|
goto end;
|
}
|
|
image->format = env->CallIntMethod(jimage, codec->getFormatMethod);
|
image->width = env->CallIntMethod(jimage, codec->getWidthMethod);
|
image->height = env->CallIntMethod(jimage, codec->getHeightMethod);
|
image->timestamp = env->CallLongMethod(jimage, codec->getTimestrampMethod);
|
|
jrect = env->CallObjectMethod(jimage, codec->getCropRectMethod);
|
if(jrect == NULL) {
|
LOGP(ERROR, "%s: could not get crop rectangle", __FUNCTION__);
|
success = FALSE;
|
goto end;
|
}
|
bottom = env->GetIntField(jrect, codec->bottomField);
|
left = env->GetIntField(jrect, codec->leftField);
|
right = env->GetIntField(jrect, codec->rightField);
|
top = env->GetIntField(jrect, codec->topField);
|
image->crop_rect.x = left;
|
image->crop_rect.y = top;
|
image->crop_rect.w = right - left;
|
image->crop_rect.h = bottom - top;
|
|
jplanes = reinterpret_cast<jobjectArray>(env->CallObjectMethod(jimage, codec->getPlanesMethod));
|
image->nplanes = env->GetArrayLength(jplanes);
|
for(int i=0; i<image->nplanes; i++) {
|
jobject jplane = env->GetObjectArrayElement(jplanes, i);
|
image->pixel_strides[i] = env->CallIntMethod(jplane, codec->getPixelStrideMethod);
|
if(env->ExceptionCheck()) {
|
image->pixel_strides[i] = -1;
|
env->ExceptionClear();
|
}
|
image->row_strides[i] = env->CallIntMethod(jplane, codec->getRowStrideMethod);
|
if(env->ExceptionCheck()) {
|
image->row_strides[i] = -1;
|
env->ExceptionClear();
|
}
|
jobject jbuffer = env->CallObjectMethod(jplane, codec->getBufferMethod);
|
image->buffers[i] = (uint8_t *)env->GetDirectBufferAddress(jbuffer);
|
env->DeleteLocalRef(jbuffer);
|
env->DeleteLocalRef(jplane);
|
}
|
|
image->priv_ptr = env->NewGlobalRef(jimage);
|
|
end:
|
if (jimage) env->DeleteLocalRef(jimage);
|
if (jplanes) env->DeleteLocalRef(jplanes);
|
if (jrect) env->DeleteLocalRef(jrect);
|
return success;
|
}
|
|
bool AMediaCodec_getInputImage(AMediaCodec * codec, int index, AMediaImage *image) {
|
JNIEnv *env = ms_get_jni_env();
|
return _getImage(env, codec, TRUE, index, image);
|
}
|
|
bool AMediaCodec_getOutputImage(AMediaCodec *codec, int index, AMediaImage *image) {
|
JNIEnv *env = ms_get_jni_env();
|
return _getImage(env, codec, FALSE, index, image);
|
}
|
|
void AMediaImage_close(AMediaImage *image) {
|
jclass imageClass = NULL;
|
jmethodID close;
|
bool_t success = TRUE;
|
|
JNIEnv *env = ms_get_jni_env();
|
jobject jimage = (jobject)image->priv_ptr;
|
|
success = success && _loadClass(env, "android/media/Image", &imageClass);
|
success = success && _getMethodID(env, imageClass, "close", "()V", &close);
|
if (!success) {
|
LOGP(ERROR, "%s: could not load some class or method ID", __FUNCTION__);
|
}
|
if (imageClass) {
|
env->CallVoidMethod(jimage, close);
|
env->DeleteLocalRef(imageClass);
|
}
|
env->DeleteGlobalRef(jimage);
|
image->priv_ptr = NULL;
|
}
|
|
bool_t AMediaImage_isAvailable(void) {
|
return ms_get_android_sdk_version() >= 22;
|
}
|
|
|
////////////////////////////////////////////////////
|
// //
|
// MEDIA FORMAT //
|
// //
|
////////////////////////////////////////////////////
|
|
bool AMediaFormat_loadMethodID(AMediaFormat * format) {
|
JNIEnv *env = ms_get_jni_env();
|
jclass mediaFormatClass = NULL;
|
jobject jformat = NULL;
|
jmethodID createID = NULL;
|
jstring msg = NULL;
|
bool success = true;
|
|
success &= _loadClass(env, "android/media/MediaFormat", &mediaFormatClass);
|
if(!success) {
|
LOGP(ERROR, "%s(): one class could not be found", __FUNCTION__);
|
goto error;
|
}
|
|
success &= _getStaticMethodID(env, mediaFormatClass, "createVideoFormat", "(Ljava/lang/String;II)Landroid/media/MediaFormat;", &createID);
|
success &= _getMethodID(env, mediaFormatClass, "setInteger", "(Ljava/lang/String;I)V", &(format->setInteger));
|
success &= _getMethodID(env, mediaFormatClass, "getInteger", "(Ljava/lang/String;)I", &(format->getInteger));
|
success &= _getMethodID(env, mediaFormatClass, "setString", "(Ljava/lang/String;Ljava/lang/String;)V", &(format->setString));
|
if(!success) {
|
LOGP(ERROR, "%s(): one method or field could not be found", __FUNCTION__);
|
goto error;
|
}
|
|
msg = env->NewStringUTF("video/avc");
|
jformat = env->CallStaticObjectMethod(mediaFormatClass, createID, msg, 240, 320);
|
if (!jformat) {
|
LOGP(ERROR, "Failed to create format !");
|
goto error;
|
}
|
|
format->jformat = env->NewGlobalRef(jformat);
|
env->DeleteLocalRef(jformat);
|
env->DeleteLocalRef(mediaFormatClass);
|
env->DeleteLocalRef(msg);
|
return true;
|
|
error:
|
if (mediaFormatClass) env->DeleteLocalRef(mediaFormatClass);
|
if (jformat) env->DeleteLocalRef(jformat);
|
if (msg) env->DeleteLocalRef(msg);
|
return false;
|
}
|
|
//STUB
|
AMediaFormat *AMediaFormat_new(void) {
|
AMediaFormat *format = ms_new0(AMediaFormat, 1);
|
|
if (!AMediaFormat_loadMethodID(format)) {
|
ms_free(format);
|
format = NULL;
|
}
|
return format;
|
}
|
|
media_status_t AMediaFormat_delete(AMediaFormat* format) {
|
JNIEnv *env = ms_get_jni_env();
|
|
env->DeleteGlobalRef(format->jformat);
|
ms_free(format);
|
|
return AMEDIA_OK;
|
}
|
|
bool AMediaFormat_getInt32(AMediaFormat *format, const char *name, int32_t *out){
|
JNIEnv *env = ms_get_jni_env();
|
|
if (!format) {
|
LOGP(ERROR, "Format nul");
|
return false;
|
}
|
|
jstring jkey = env->NewStringUTF(name);
|
jint jout = env->CallIntMethod(format->jformat, format->getInteger, jkey);
|
*out = jout;
|
env->DeleteLocalRef(jkey);
|
handle_java_exception();
|
|
return true;
|
}
|
|
void AMediaFormat_setInt32(AMediaFormat *format, const char* name, int32_t value) {
|
JNIEnv *env = ms_get_jni_env();
|
jstring jkey = env->NewStringUTF(name);
|
env->CallVoidMethod(format->jformat, format->setInteger, jkey, value);
|
env->DeleteLocalRef(jkey);
|
handle_java_exception();
|
}
|
|
void AMediaFormat_setString(AMediaFormat *format, const char* key, const char* name) {
|
JNIEnv *env = ms_get_jni_env();
|
|
jstring jkey = env->NewStringUTF(key);
|
jstring jvalue = env->NewStringUTF(name);
|
env->CallVoidMethod(format->jformat, format->setString, jkey, jvalue);
|
env->DeleteLocalRef(jkey);
|
env->DeleteLocalRef(jvalue);
|
handle_java_exception();
|
}
|
|
const char* AMediaFormat_toString(AMediaFormat*)
|
{
|
return "";
|
}
|
