安卓 c语言 图片处理,Android_JNI实例(模仿足记图片处理加字幕)

最新推荐文章于 2022-05-19 15:54:24 发布
最新推荐文章于 2022-05-19 15:54:24 发布
阅读量170 收藏 1
点赞数
文章标签： 安卓 c语言 图片处理

前言

总所周知，android应用的编写是基于Java语言的，Java语言的特点决定了Java执行效率较底层语言会低很多，不像机器语言或者C语言这些能通过解释器直接转换成CPU能识别的机器码。

a0b156e070ac?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

java执行的流程图.png

在一个数据量比较大的业务场景，例如图片、音视频、大文本处理等场景，使用JNI来调用C语言来执行比Java执行会有先天的优势，另一个原因就是在android平台上，C语言的native层的内存使用并不受JVM的内存分配限制。简单的说，能用更多的内存，更底层的语言来处理这些数据量大的业务。

什么是Android_JNI

可以参考Android NDK开发：JNI基础篇

简单的讲Jni就是提供了Java调用C语言的接口，并且屏蔽了Java层和C层之间的数据类型之间的差异，提供了C层和Java层互相调用的接口。

Android_JNI的使用

AndroidStudio在3.0以后集成了NDK开发对应的套件，不需要在单独的使用javac、javah来生成所需的Jni的声明文件(.h文件)和执行文件(.cpp文件)

方法的声明

extern "C"{

jintArray JNICALL

Java_com_wiki_testjni_MainActivity_getImgToGray(JNIEnv *env, jobject instance,

jintArray data_, jint w, jint h);

}

方法的申明只需要按照上面的格式，即Java_包名_native方法名即可，变量*env和instance是JNI方法默认带的参数，这个后面会提到。

方法的执行格式如下：

JNIEXPORT jintArray JNICALL

Java_com_wiki_testjni_MainActivity_getImgToGray(JNIEnv *env, jobject instance,

jintArray data_, jint w, jint h) {

jint *data;

data = env->GetIntArrayElements(data_, NULL);

if (data == NULL) {

return 0; /* exception occurred */

}

int alpha = 0xFF << 24;

for (int i = 0; i < h; i++) {

for (int j = 0; j < w; j++) {

// 获得像素的颜色

int color = data[w * i + j];

int red = ((color & 0x00FF0000) >> 16);

int green = ((color & 0x0000FF00) >> 8);

int blue = color & 0x000000FF;

color = (red + green + blue) / 3;

color = alpha | (color << 16) | (color << 8) | color;

data[w * i + j] = color;

}

}

int size=w * h;

jintArray result = env->NewIntArray(size);

env->SetIntArrayRegion(result, 0, size, data);

env->ReleaseIntArrayElements(data_, data, 0);

return result;

}

方法的执行格式如下JNIEXPORT +返回的java数据类型+JNICALL

Android_JNI的使用中重要的方法和变量

androidJNI使用中最重要的变量莫过于JNIEnv *env和jobject instance。

instance实际上是调用jni方法的对象的实例，这个不多讨论，主要讨论一下JNIEnv *env

首先看一下JNIEnv的代码

struct _JNIEnv {

/* do not rename this; it does not seem to be entirely opaque */

const struct JNINativeInterface* functions;

#if defined(__cplusplus)

jint GetVersion()

{ return functions->GetVersion(this); }

jclass DefineClass(const char *name, jobject loader, const jbyte* buf,

jsize bufLen)

{ return functions->DefineClass(this, name, loader, buf, bufLen); }

jclass FindClass(const char* name)

{ return functions->FindClass(this, name); }

jmethodID FromReflectedMethod(jobject method)

{ return functions->FromReflectedMethod(this, method); }

jfieldID FromReflectedField(jobject field)

{ return functions->FromReflectedField(this, field); }

jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic)

{ return functions->ToReflectedMethod(this, cls, methodID, isStatic); }

jclass GetSuperclass(jclass clazz)

{ return functions->GetSuperclass(this, clazz); }

jboolean IsAssignableFrom(jclass clazz1, jclass clazz2)

{ return functions->IsAssignableFrom(this, clazz1, clazz2); }

jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic)

{ return functions->ToReflectedField(this, cls, fieldID, isStatic); }

jint Throw(jthrowable obj)

{ return functions->Throw(this, obj); }

jint ThrowNew(jclass clazz, const char* message)

{ return functions->ThrowNew(this, clazz, message); }

jthrowable ExceptionOccurred()

{ return functions->ExceptionOccurred(this); }

void ExceptionDescribe()

{ functions->ExceptionDescribe(this); }

void ExceptionClear()

{ functions->ExceptionClear(this); }

void FatalError(const char* msg)

{ functions->FatalError(this, msg); }

jint PushLocalFrame(jint capacity)

{ return functions->PushLocalFrame(this, capacity); }

jobject PopLocalFrame(jobject result)

{ return functions->PopLocalFrame(this, result); }

jobject NewGlobalRef(jobject obj)

{ return functions->NewGlobalRef(this, obj); }

void DeleteGlobalRef(jobject globalRef)

{ functions->DeleteGlobalRef(this, globalRef); }

void DeleteLocalRef(jobject localRef)

{ functions->DeleteLocalRef(this, localRef); }

jboolean IsSameObject(jobject ref1, jobject ref2)

{ return functions->IsSameObject(this, ref1, ref2); }

jobject NewLocalRef(jobject ref)

{ return functions->NewLocalRef(this, ref); }

jint EnsureLocalCapacity(jint capacity)

{ return functions->EnsureLocalCapacity(this, capacity); }

jobject AllocObject(jclass clazz)

{ return functions->AllocObject(this, clazz); }

jobject NewObject(jclass clazz, jmethodID methodID, ...)

{

va_list args;

va_start(args, methodID);

jobject result = functions->NewObjectV(this, clazz, methodID, args);

va_end(args);

return result;

}

jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args)

{ return functions->NewObjectV(this, clazz, methodID, args); }

jobject NewObjectA(jclass clazz, jmethodID methodID, const jvalue* args)

{ return functions->NewObjectA(this, clazz, methodID, args); }

jclass GetObjectClass(jobject obj)

{ return functions->GetObjectClass(this, obj); }

jboolean IsInstanceOf(jobject obj, jclass clazz)

{ return functions->IsInstanceOf(this, obj, clazz); }

jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)

{ return functions->GetMethodID(this, clazz, name, sig); }

#define CALL_TYPE_METHOD(_jtype, _jname) \

_jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...) \

{ \

_jtype result; \

va_list args; \

va_start(args, methodID); \

result = functions->Call##_jname##MethodV(this, obj, methodID, \

args); \

va_end(args); \

return result; \

}

#define CALL_TYPE_METHODV(_jtype, _jname) \

_jtype Call##_jname##MethodV(jobject obj, jmethodID methodID, \

va_list args) \

{ return functions->Call##_jname##MethodV(this, obj, methodID, args); }

#define CALL_TYPE_METHODA(_jtype, _jname) \

_jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \

const jvalue* args) \

{ return functions->Call##_jname##MethodA(this, obj, methodID, args); }

#define CALL_TYPE(_jtype, _jname) \

CALL_TYPE_METHOD(_jtype, _jname) \

CALL_TYPE_METHODV(_jtype, _jname) \

CALL_TYPE_METHODA(_jtype, _jname)

CALL_TYPE(jobject, Object)

CALL_TYPE(jboolean, Boolean)

CALL_TYPE(jbyte, Byte)

CALL_TYPE(jchar, Char)

CALL_TYPE(jshort, Short)

CALL_TYPE(jint, Int)

CALL_TYPE(jlong, Long)

CALL_TYPE(jfloat, Float)

CALL_TYPE(jdouble, Double)

void CallVoidMethod(jobject obj, jmethodID methodID, ...)

{

va_list args;

va_start(args, methodID);

functions->CallVoidMethodV(this, obj, methodID, args);

va_end(args);

}

void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args)

{ functions->CallVoidMethodV(this, obj, methodID, args); }

void CallVoidMethodA(jobject obj, jmethodID methodID, const jvalue* args)

{ functions->CallVoidMethodA(this, obj, methodID, args); }

#define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \

_jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz, \

jmethodID methodID, ...) \

{ \

_jtype result; \

va_list args; \

va_start(args, methodID); \

result = functions->CallNonvirtual##_jname##MethodV(this, obj, \

clazz, methodID, args); \

va_end(args); \

return result; \

}

#define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \

_jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz, \

jmethodID methodID, va_list args) \

{ return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz, \

methodID, args); }

#define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \

_jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \

jmethodID methodID, const jvalue* args) \

{ return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \

methodID, args); }

#define CALL_NONVIRT_TYPE(_jtype, _jname) \

CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \

CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \

CALL_NONVIRT_TYPE_METHODA(_jtype, _jname)

CALL_NONVIRT_TYPE(jobject, Object)

CALL_NONVIRT_TYPE(jboolean, Boolean)

CALL_NONVIRT_TYPE(jbyte, Byte)

CALL_NONVIRT_TYPE(jchar, Char)

CALL_NONVIRT_TYPE(jshort, Short)

CALL_NONVIRT_TYPE(jint, Int)

CALL_NONVIRT_TYPE(jlong, Long)

CALL_NONVIRT_TYPE(jfloat, Float)

CALL_NONVIRT_TYPE(jdouble, Double)

void CallNonvirtualVoidMethod(jobject obj, jclass clazz,

jmethodID methodID, ...)

{

va_list args;

va_start(args, methodID);

functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args);

va_end(args);

}

void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,

jmethodID methodID, va_list args)

{ functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); }

void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,

jmethodID methodID, const jvalue* args)

{ functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); }

jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)

{ return functions->GetFieldID(this, clazz, name, sig); }

jobject GetObjectField(jobject obj, jfieldID fieldID)

{ return functions->GetObjectField(this, obj, fieldID); }

jboolean GetBooleanField(jobject obj, jfieldID fieldID)

{ return functions->GetBooleanField(this, obj, fieldID); }

jbyte GetByteField(jobject obj, jfieldID fieldID)

{ return functions->GetByteField(this, obj, fieldID); }

jchar GetCharField(jobject obj, jfieldID fieldID)

{ return functions->GetCharField(this, obj, fieldID); }

jshort GetShortField(jobject obj, jfieldID fieldID)

{ return functions->GetShortField(this, obj, fieldID); }

jint GetIntField(jobject obj, jfieldID fieldID)

{ return functions->GetIntField(this, obj, fieldID); }

jlong GetLongField(jobject obj, jfieldID fieldID)

{ return functions->GetLongField(this, obj, fieldID); }

jfloat GetFloatField(jobject obj, jfieldID fieldID)

{ return functions->GetFloatField(this, obj, fieldID); }

jdouble GetDoubleField(jobject obj, jfieldID fieldID)

{ return functions->GetDoubleField(this, obj, fieldID); }

void SetObjectField(jobject obj, jfieldID fieldID, jobject value)

{ functions->SetObjectField(this, obj, fieldID, value); }

void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value)

{ functions->SetBooleanField(this, obj, fieldID, value); }

void SetByteField(jobject obj, jfieldID fieldID, jbyte value)

{ functions->SetByteField(this, obj, fieldID, value); }

void SetCharField(jobject obj, jfieldID fieldID, jchar value)

{ functions->SetCharField(this, obj, fieldID, value); }

void SetShortField(jobject obj, jfieldID fieldID, jshort value)

{ functions->SetShortField(this, obj, fieldID, value); }

void SetIntField(jobject obj, jfieldID fieldID, jint value)

{ functions->SetIntField(this, obj, fieldID, value); }

void SetLongField(jobject obj, jfieldID fieldID, jlong value)

{ functions->SetLongField(this, obj, fieldID, value); }

void SetFloatField(jobject obj, jfieldID fieldID, jfloat value)

{ functions->SetFloatField(this, obj, fieldID, value); }

void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value)

{ functions->SetDoubleField(this, obj, fieldID, value); }

jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig)

{ return functions->GetStaticMethodID(this, clazz, name, sig); }

#define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \

_jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \

...) \

{ \

_jtype result; \

va_list args; \

va_start(args, methodID); \

result = functions->CallStatic##_jname##MethodV(this, clazz, \

methodID, args); \

va_end(args); \

return result; \

}

#define CALL_STATIC_TYPE_METHODV(_jtype, _jname) \

_jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID, \

va_list args) \

{ return functions->CallStatic##_jname##MethodV(this, clazz, methodID, \

args); }

#define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \

_jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \

const jvalue* args) \

{ return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \

args); }

#define CALL_STATIC_TYPE(_jtype, _jname) \

CALL_STATIC_TYPE_METHOD(_jtype, _jname) \

CALL_STATIC_TYPE_METHODV(_jtype, _jname) \

CALL_STATIC_TYPE_METHODA(_jtype, _jname)

CALL_STATIC_TYPE(jobject, Object)

CALL_STATIC_TYPE(jboolean, Boolean)

CALL_STATIC_TYPE(jbyte, Byte)

CALL_STATIC_TYPE(jchar, Char)

CALL_STATIC_TYPE(jshort, Short)

CALL_STATIC_TYPE(jint, Int)

CALL_STATIC_TYPE(jlong, Long)

CALL_STATIC_TYPE(jfloat, Float)

CALL_STATIC_TYPE(jdouble, Double)

void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...)

{

va_list args;

va_start(args, methodID);

functions->CallStaticVoidMethodV(this, clazz, methodID, args);

va_end(args);

}

void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args)

{ functions->CallStaticVoidMethodV(this, clazz, methodID, args); }

void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, const jvalue* args)

{ functions->CallStaticVoidMethodA(this, clazz, methodID, args); }

jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig)

{ return functions->GetStaticFieldID(this, clazz, name, sig); }

jobject GetStaticObjectField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticObjectField(this, clazz, fieldID); }

jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticBooleanField(this, clazz, fieldID); }

jbyte GetStaticByteField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticByteField(this, clazz, fieldID); }

jchar GetStaticCharField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticCharField(this, clazz, fieldID); }

jshort GetStaticShortField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticShortField(this, clazz, fieldID); }

jint GetStaticIntField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticIntField(this, clazz, fieldID); }

jlong GetStaticLongField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticLongField(this, clazz, fieldID); }

jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticFloatField(this, clazz, fieldID); }

jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID)

{ return functions->GetStaticDoubleField(this, clazz, fieldID); }

void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value)

{ functions->SetStaticObjectField(this, clazz, fieldID, value); }

void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value)

{ functions->SetStaticBooleanField(this, clazz, fieldID, value); }

void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value)

{ functions->SetStaticByteField(this, clazz, fieldID, value); }

void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value)

{ functions->SetStaticCharField(this, clazz, fieldID, value); }

void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value)

{ functions->SetStaticShortField(this, clazz, fieldID, value); }

void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value)

{ functions->SetStaticIntField(this, clazz, fieldID, value); }

void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value)

{ functions->SetStaticLongField(this, clazz, fieldID, value); }

void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value)

{ functions->SetStaticFloatField(this, clazz, fieldID, value); }

void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value)

{ functions->SetStaticDoubleField(this, clazz, fieldID, value); }

jstring NewString(const jchar* unicodeChars, jsize len)

{ return functions->NewString(this, unicodeChars, len); }

jsize GetStringLength(jstring string)

{ return functions->GetStringLength(this, string); }

const jchar* GetStringChars(jstring string, jboolean* isCopy)

{ return functions->GetStringChars(this, string, isCopy); }

void ReleaseStringChars(jstring string, const jchar* chars)

{ functions->ReleaseStringChars(this, string, chars); }

jstring NewStringUTF(const char* bytes)

{ return functions->NewStringUTF(this, bytes); }

jsize GetStringUTFLength(jstring string)

{ return functions->GetStringUTFLength(this, string); }

const char* GetStringUTFChars(jstring string, jboolean* isCopy)

{ return functions->GetStringUTFChars(this, string, isCopy); }

void ReleaseStringUTFChars(jstring string, const char* utf)

{ functions->ReleaseStringUTFChars(this, string, utf); }

jsize GetArrayLength(jarray array)

{ return functions->GetArrayLength(this, array); }

jobjectArray NewObjectArray(jsize length, jclass elementClass,

jobject initialElement)

{ return functions->NewObjectArray(this, length, elementClass,

initialElement); }

jobject GetObjectArrayElement(jobjectArray array, jsize index)

{ return functions->GetObjectArrayElement(this, array, index); }

void SetObjectArrayElement(jobjectArray array, jsize index, jobject value)

{ functions->SetObjectArrayElement(this, array, index, value); }

jbooleanArray NewBooleanArray(jsize length)

{ return functions->NewBooleanArray(this, length); }

jbyteArray NewByteArray(jsize length)

{ return functions->NewByteArray(this, length); }

jcharArray NewCharArray(jsize length)

{ return functions->NewCharArray(this, length); }

jshortArray NewShortArray(jsize length)

{ return functions->NewShortArray(this, length); }

jintArray NewIntArray(jsize length)

{ return functions->NewIntArray(this, length); }

jlongArray NewLongArray(jsize length)

{ return functions->NewLongArray(this, length); }

jfloatArray NewFloatArray(jsize length)

{ return functions->NewFloatArray(this, length); }

jdoubleArray NewDoubleArray(jsize length)

{ return functions->NewDoubleArray(this, length); }

jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy)

{ return functions->GetBooleanArrayElements(this, array, isCopy); }

jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy)

{ return functions->GetByteArrayElements(this, array, isCopy); }

jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy)

{ return functions->GetCharArrayElements(this, array, isCopy); }

jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy)

{ return functions->GetShortArrayElements(this, array, isCopy); }

jint* GetIntArrayElements(jintArray array, jboolean* isCopy)

{ return functions->GetIntArrayElements(this, array, isCopy); }

jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy)

{ return functions->GetLongArrayElements(this, array, isCopy); }

jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy)

{ return functions->GetFloatArrayElements(this, array, isCopy); }

jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy)

{ return functions->GetDoubleArrayElements(this, array, isCopy); }

void ReleaseBooleanArrayElements(jbooleanArray array, jboolean* elems,

jint mode)

{ functions->ReleaseBooleanArrayElements(this, array, elems, mode); }

void ReleaseByteArrayElements(jbyteArray array, jbyte* elems,

jint mode)

{ functions->ReleaseByteArrayElements(this, array, elems, mode); }

void ReleaseCharArrayElements(jcharArray array, jchar* elems,

jint mode)

{ functions->ReleaseCharArrayElements(this, array, elems, mode); }

void ReleaseShortArrayElements(jshortArray array, jshort* elems,

jint mode)

{ functions->ReleaseShortArrayElements(this, array, elems, mode); }

void ReleaseIntArrayElements(jintArray array, jint* elems,

jint mode)

{ functions->ReleaseIntArrayElements(this, array, elems, mode); }

void ReleaseLongArrayElements(jlongArray array, jlong* elems,

jint mode)

{ functions->ReleaseLongArrayElements(this, array, elems, mode); }

void ReleaseFloatArrayElements(jfloatArray array, jfloat* elems,

jint mode)

{ functions->ReleaseFloatArrayElements(this, array, elems, mode); }

void ReleaseDoubleArrayElements(jdoubleArray array, jdouble* elems,

jint mode)

{ functions->ReleaseDoubleArrayElements(this, array, elems, mode); }

void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,

jboolean* buf)

{ functions->GetBooleanArrayRegion(this, array, start, len, buf); }

void GetByteArrayRegion(jbyteArray array, jsize start, jsize len,

jbyte* buf)

{ functions->GetByteArrayRegion(this, array, start, len, buf); }

void GetCharArrayRegion(jcharArray array, jsize start, jsize len,

jchar* buf)

{ functions->GetCharArrayRegion(this, array, start, len, buf); }

void GetShortArrayRegion(jshortArray array, jsize start, jsize len,

jshort* buf)

{ functions->GetShortArrayRegion(this, array, start, len, buf); }

void GetIntArrayRegion(jintArray array, jsize start, jsize len,

jint* buf)

{ functions->GetIntArrayRegion(this, array, start, len, buf); }

void GetLongArrayRegion(jlongArray array, jsize start, jsize len,

jlong* buf)

{ functions->GetLongArrayRegion(this, array, start, len, buf); }

void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len,

jfloat* buf)

{ functions->GetFloatArrayRegion(this, array, start, len, buf); }

void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,

jdouble* buf)

{ functions->GetDoubleArrayRegion(this, array, start, len, buf); }

void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,

const jboolean* buf)

{ functions->SetBooleanArrayRegion(this, array, start, len, buf); }

void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,

const jbyte* buf)

{ functions->SetByteArrayRegion(this, array, start, len, buf); }

void SetCharArrayRegion(jcharArray array, jsize start, jsize len,

const jchar* buf)

{ functions->SetCharArrayRegion(this, array, start, len, buf); }

void SetShortArrayRegion(jshortArray array, jsize start, jsize len,

const jshort* buf)

{ functions->SetShortArrayRegion(this, array, start, len, buf); }

void SetIntArrayRegion(jintArray array, jsize start, jsize len,

const jint* buf)

{ functions->SetIntArrayRegion(this, array, start, len, buf); }

void SetLongArrayRegion(jlongArray array, jsize start, jsize len,

const jlong* buf)

{ functions->SetLongArrayRegion(this, array, start, len, buf); }

void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,

const jfloat* buf)

{ functions->SetFloatArrayRegion(this, array, start, len, buf); }

void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,

const jdouble* buf)

{ functions->SetDoubleArrayRegion(this, array, start, len, buf); }

jint RegisterNatives(jclass clazz, const JNINativeMethod* methods,

jint nMethods)

{ return functions->RegisterNatives(this, clazz, methods, nMethods); }

jint UnregisterNatives(jclass clazz)

{ return functions->UnregisterNatives(this, clazz); }

jint MonitorEnter(jobject obj)

{ return functions->MonitorEnter(this, obj); }

jint MonitorExit(jobject obj)

{ return functions->MonitorExit(this, obj); }

jint GetJavaVM(JavaVM** vm)

{ return functions->GetJavaVM(this, vm); }

void GetStringRegion(jstring str, jsize start, jsize len, jchar* buf)

{ functions->GetStringRegion(this, str, start, len, buf); }

void GetStringUTFRegion(jstring str, jsize start, jsize len, char* buf)

{ return functions->GetStringUTFRegion(this, str, start, len, buf); }

void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy)

{ return functions->GetPrimitiveArrayCritical(this, array, isCopy); }

void ReleasePrimitiveArrayCritical(jarray array, void* carray, jint mode)

{ functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); }

const jchar* GetStringCritical(jstring string, jboolean* isCopy)

{ return functions->GetStringCritical(this, string, isCopy); }

void ReleaseStringCritical(jstring string, const jchar* carray)

{ functions->ReleaseStringCritical(this, string, carray); }

jweak NewWeakGlobalRef(jobject obj)

{ return functions->NewWeakGlobalRef(this, obj); }

void DeleteWeakGlobalRef(jweak obj)

{ functions->DeleteWeakGlobalRef(this, obj); }

jboolean ExceptionCheck()

{ return functions->ExceptionCheck(this); }

jobject NewDirectByteBuffer(void* address, jlong capacity)

{ return functions->NewDirectByteBuffer(this, address, capacity); }

void* GetDirectBufferAddress(jobject buf)

{ return functions->GetDirectBufferAddress(this, buf); }

jlong GetDirectBufferCapacity(jobject buf)

{ return functions->GetDirectBufferCapacity(this, buf); }

/* added in JNI 1.6 */

jobjectRefType GetObjectRefType(jobject obj)

{ return functions->GetObjectRefType(this, obj); }

#endif /*__cplusplus*/

};

代码比较长，可以看到JNIEnv实际上就是一个函数列表的指针，函数列表里面封装了开发者用到的常用函数，这些函数大体分成两类，一类是类似GetStaticFieldID这些于java层交互的函数，这些函数的用途大体上就是生成java对象，调用java方法，设置java类实例的变量等等，另一类则是GetIntArrayElements，ReleaseIntArrayElements这些对于内存的分配回收等使用方法的封装，方便了开发者对于内存的管理。

值得注意的是，本人在android源码中并没有搜索到这些函数列表方法的具体实现，这些函数的实现应该是在系统初始化的时候从bootloader启动后从固态存储器读取系统后也把相应的这些函数实现读取到内存的不可修改的数据段中。

实现原理

足记里的图片处理加字幕，实际上就是针对图片添加相应的滤镜，对图片的每个像素进行修正，达到特点的效果，例如灰度效果，冷暖色调，底片效果等等。关于图片的处理大多是基于open gl的，本实例的代码也有一部分是根据open gl的代码转换成c代码。至于字幕的添加就比较简单了，通过布局将文本控件覆盖在图片上。

a0b156e070ac?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

jni效果图.gif

代码地址

提取码: tm7i

weixin_39891262
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android studio用C++，jni接口，opencv实现图像处理
Lumos_somuL的博客
03-18 6312
一，jni的配置以及初步实现在此篇（https://blog.csdn.net/Lumos_somuL/article/details/123486353?spm=1001.2014.3001.5501）内容中，本文接上篇（https://blog.csdn.net/Lumos_somuL/article/details/123486353?spm=1001.2014.3001.5501）内容 一、 ...
安卓 c语言 图片处理,android 图片相关处理
weixin_36034883的博客
05-18 653
怎么使用代码获取android中图片资源名称:http://zhidao.baidu.com/link?url=6EKTWe14lrXYxoasRSJFrTRbbEjojobgyySUOni4CmO4p9Ok9KUKtmVrrGc0Ho9Js8LF3MvoYvLnV-VHb2WQBEQipoxPWZjDVMeXeLnJtVWAndroid 如何给登陆背景加一层模糊,如图所示:http://zhid...
GetByteArrayElements和ReleaseByteArrayElements
weixin_34116110的博客
12-21 1572
2019独角兽企业重金招聘Python工程师标准>>> ...
android JNIEnv实现
ConceptCon
12-25 2682
当用到JNI时，总不明白JNIEnv这个东东是个啥，有啥用；这次总算在源码中找到了它的实现，做个记录。。。。 android_source_code_dir\dalvik\libnativehelper\include\nativehelper\Jni.h /* * C++ object wrapper. * * This is usually overlaid on a C str
jni.zip_Android jni_android_jni_jni android
09-21
本资源“jni.zip_Android jni_android_jni_jni android”包含了一份关于Android环境下JNI使用的详细指南。 JNI的核心概念主要包括以下几个方面： 1. **本地方法接口**：JNI定义了一套API，使得Java代码可以调用C/...
android-jni.zip_Android jni_android_jni_jni android
最新发布
09-22
Android JNI（Java Native Interface）是Android系统中一个重要的技术，它允许Java代码和其他语言写的代码进行交互。JNI在Android开发中扮演着不可或缺的角色，尤其是在进行性能优化、利用硬件加速、调用C/C++库或者...
JniCallback.zip_Android jni_android_jni android_jni callback_jni
09-14
在Android开发中，JNI（Java Native Interface）是一个关键的技术，它允许Java代码和其他语言写的代码进行交互。JNI在很多场景下都非常有用，比如优化性能、使用现有的C/C++库、或者像在这个“JniCallback.zip”文件...
Android_NDK_android端_图片处理_android_NDK_ndk开发_
10-03
本文将详细介绍Android NDK在Android端图片处理中的应用以及NDK开发的相关知识点。 1. **Android NDK简介** Android NDK是一套工具，允许开发者在Android应用中使用C和C++代码。它提供了头文件和库，使得在原生...
android_jni.rar_android_android_jni
09-14
这个"android_jni.rar"压缩包提供了一份关于Android JNI编程的基本文档，对想要深入学习Android底层开发的朋友们来说，是一份非常有价值的参考资料。 1. **JNI简介**： JNI是Java平台的一部分，为Java程序员提供了...
[2017.07.06][C语言]在Android上，通过读写fb0(FrameBuffer)，实现截图和显示BMP图片
07-06
http://blog.csdn.net/victoryckl/article/details/7277156 在Android上，通过对/dev/graphics/fb0的操作，实现截屏，和送图片到fb0，支持rgb565 rgb888 bgra_8888 格式的bmp和fb0 需要root权限 修正了framebuffer bgra_8888格式截图变红的问题
Android 通过jni返回Mat数据类型方法
08-27
今天小编就为大家分享一篇Android 通过jni返回Mat数据类型方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
在Android中使用OpenCv 来处理图片
热门推荐
ghd2000的专栏
04-29 2万+
最近在研究在用C来处理图片，后来再网上找了一下，有的说用libjpeg和opencv来处理图片。先研究一下，opencv来处理图片，这是网上一位友人写的代码http://blogold.chinaunix.net/u1/57901/showart.php?id=2512389开始之前，你必须得到 libandroid-opencv.so库 ，请参考这位牛人的博客http://blog.csdn.net/hellogv/archive/2011/01/21/6157316.aspx1、创建一个android工
Android端图像处理方法总结
晓风的博客
07-13 6827
Android端图像处理方法 在Android机中进行图像处理，常用的方式有两种： 一种是单纯使用JAVA语言进行图形处理，相当于你将C或者C++编写的图像处理方法，又重新用JAVA编写了一遍。这种开发方法需要你在opencv官网，首先下载好Opencv的Android的版本，然后将它配置到你的项目中，这样你进行图像处理时就可以直接调用一些现成的方法，比如灰度化、边缘化处理、图...
使用Android Studio进行JNI开发 － Mac篇
weixin_34112030的博客
09-09 123
2019独角兽企业重金招聘Python工程师标准>>> ...
按下电源键到启动Home应用过程详解（三）
yi_master的博客
07-12 1886
一： 这篇将分析手机从加电那一刻到Home应用启动的过程，如下图简要描述了启动过程 system_server在开启核心服务的时候，其中有一个服务是ActivityManagerService，简称AMS; 主要负责系统中四大组件的启动、切换、调度及应用进程的管理和调度等工作,在系统进程到ready阶段的时候，AMS将会和Zygote中的socker进行通信，通过zygote启动Home应用二：关
JNI 技巧
weixin_33759269的博客
08-06 196
JNI 是指 Java 本地层接口（Java Native Int...
java 图片插值二值化_图像基本处理算法的简单实现（一）
weixin_42227109的博客
02-25 545
图像基本处理算法的简单实现(一)一、引言图像处理基本算法整理。拿来举例的实现代码是在JNI方法内直接实现的，且传入参数为int[]颜色值，返回为新的int[]颜色值，可能头上还包括了长宽。(很丑，见谅T^T)2.2的NDK提供了Bitmap.h，这种方式可参考《Android NDK基础样例》的样例3，灰度化图像(Bitmap作为参数)。二、目录1)缩放算法据说有最邻近插值、双线性内插值、高阶插值...
JNI内存方面说明以及相关类型手动释放内存
nanke_yh的博客
05-19 4512
JNI如果创建以上引用却不手动释放的话很容易就造成内存泄露，所以JNI编程创建的引用类型一定要手动释放（切身教训），检测内存泄露可以使用Jprofiler
Android JNI 实例解析
"Android JNI是Android系统中用于Java和C/C++之间通信的技术，通过JNI可以调用原生代码库，实现高效的计算或利用现有的C++库。此文档由Jurij Smakov编写，包含了JNI的介绍、Java接口、本地库实现、头文件和全局变量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值