#include <linux/gpio.h>
|
|
#include <jni.h>
|
#include <string>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <sys/time.h>
|
#include <time.h>
|
|
#include "FiStdDefEx.h"
|
#include "THFaceImage_i.h"
|
#include <setjmp.h>
|
|
#include "FaceDetectHelper.h"
|
#include "LogUtil.h"
|
|
#include <memory>
|
#include <opencv2/opencv.hpp>
|
#include "THFeature_i.h"
|
|
#include <map>
|
#include <list>
|
#include <algorithm>
|
|
#include <memory>
|
#include <unordered_map>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <sys/time.h>
|
#include <time.h>
|
|
#include "RgbDetect.h"
|
#include "GrayDetect.h"
|
#include "LivenessDetect.h"
|
|
#include "FiStdDefEx.h"
|
|
#include <memory>
|
#include "THFeature_i.h"
|
|
#include "FaceDetectHelper.h"
|
#include "LogUtil.h"
|
#include <memory>
|
#include <sstream>
|
#include "TrackingTrigger.h"
|
#include <map>
|
|
#include <memory>
|
#include "THFeature_i.h"
|
#include <sys/time.h>
|
#include <time.h>
|
#include <iostream>
|
#include <string>
|
#include <cstring>
|
#include <android/log.h>
|
#include <android/native_window.h>
|
#include <android/native_window_jni.h>
|
|
#define TAG "jni ndk "
|
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)
|
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
|
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG,__VA_ARGS__)
|
extern "C" {
|
}
|
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,"testff",__VA_ARGS__)
|
|
|
unsigned char* ConvertJByteaArrayToChars(JNIEnv *env, jbyteArray bytearray)
|
{
|
unsigned char *chars = NULL;
|
jbyte *bytes;
|
bytes = env->GetByteArrayElements(bytearray, 0);
|
int chars_len = env->GetArrayLength(bytearray);
|
chars = new unsigned char[chars_len + 1];
|
memset(chars,0,chars_len + 1);
|
memcpy(chars, bytes, chars_len);
|
chars[chars_len] = 0;
|
env->ReleaseByteArrayElements(bytearray, bytes, 0);
|
|
return chars;
|
}
|
|
#include "yuv2bgr.h"
|
extern "C" JNIEXPORT jbyteArray
|
JNICALL
|
Java_com_basic_security_utils_FaceId_yuv420p2rgb24(
|
JNIEnv *env, jobject, jbyteArray yuvbuffer, jbyteArray rgbbuffer, int width, int height) {
|
|
unsigned char *yuvData = ConvertJByteaArrayToChars(env,yuvbuffer);
|
// unsigned char *rgbData = ConvertJByteaArrayToChars(env,rgbbuffer);
|
yuv420p_to_rgb24_c(yuvData, (unsigned char*)rgbbuffer, width, height);
|
|
delete yuvData;
|
|
//
|
//// jbyteArray ret = (*env)->NewByteArray(640*480*3);
|
// jbyte* p = env-> GetByteArrayElements(rgbbuffer, 0);
|
// FaceDetectHelper::getInstance()->yuv420p_to_rgb24_jni(env, yuvbuffer, p, width, height);
|
//// LogUtil::log(faces);
|
//// std::cout << faces <<std::endl;
|
//// return env->NewStringUTF(faces.c_str());
|
|
return rgbbuffer;
|
}
|
|
|
mutex featureListMutex;
|
|
mutex tempFeatureLock;
|
|
extern "C" JNIEXPORT jboolean
|
JNICALL
|
Java_com_basic_security_utils_FaceId_initSdk(
|
JNIEnv *env, jobject, jstring jModelPath) {
|
const char *modelPath = env->GetStringUTFChars(jModelPath, 0);
|
jboolean success = false;
|
success = FaceDetectHelper::getInstance()->initSdk(modelPath);
|
|
return success;
|
|
|
}
|
|
|
jint getIntValue(JNIEnv *env, jobject detectedResult, char *fieldName) {
|
jclass detectedResultClass = env->GetObjectClass(detectedResult);
|
jfieldID isRgbFieldId = env->GetFieldID(detectedResultClass, fieldName, "I");
|
jint intValue = env->GetIntField(detectedResult, isRgbFieldId);
|
return intValue;
|
}
|
|
jboolean getBooleanValue(JNIEnv *env, jobject detectedResult, char *fieldName) {
|
jclass detectedResultClass = env->GetObjectClass(detectedResult);
|
jfieldID isRgbFieldId = env->GetFieldID(detectedResultClass, fieldName, "Z");
|
jboolean isRgb = env->GetBooleanField(detectedResult, isRgbFieldId);
|
return isRgb;
|
}
|
bool useFeatureList = false;
|
namespace main {
|
BYTE features[10][2560];
|
int featureSize = 2560;
|
TrackingTrigger trackingTrigger(0.8);
|
ScoredRect sr;
|
long track_id[10];
|
bool liveness[10];
|
string featureNames[10];
|
|
double prevExtractFeatureTime = 0;
|
|
unsigned char *rgbBuffer = new unsigned char[640 * 480 * 3];
|
unsigned char *grayBuffer = new unsigned char[640 * 480 * 3];
|
THFI_FacePos rgbFps1[10];
|
THFI_FacePos grayFps1[10];
|
|
double msecond() {
|
struct timeval tv;
|
gettimeofday(&tv, 0);
|
return (tv.tv_sec * 1.0e3 + tv.tv_usec * 1.0e-3);
|
}
|
}
|
|
void setIntValue(JNIEnv *env, jobject detectedResult, char *fieldName, jint value) {
|
jclass detectedResultClass = env->GetObjectClass(detectedResult);
|
jfieldID isRgbFieldId = env->GetFieldID(detectedResultClass, fieldName, "I");
|
env->SetIntField(detectedResult, isRgbFieldId, value);
|
}
|
|
extern "C" JNIEXPORT void
|
JNICALL
|
Java_com_basic_security_utils_FaceId_detectFace(
|
JNIEnv *env, jobject, jobject detectedResult) {
|
jboolean isRgb = getBooleanValue(env, detectedResult, "isRgb");
|
int width = getIntValue(env, detectedResult, "width");
|
int height = getIntValue(env, detectedResult, "height");
|
jboolean shouldExtractFeature = getBooleanValue(env, detectedResult, "shouldExtractFeature");
|
jclass detectedResultClass = env->GetObjectClass(detectedResult);
|
jfieldID bgrDataFieldId = env->GetFieldID(detectedResultClass, "bgrData", "[B");
|
jobject bgrData = env->GetObjectField(detectedResult, bgrDataFieldId);
|
jbyteArray bgrDataByteArray = reinterpret_cast<jbyteArray>(bgrData);
|
int len = env->GetArrayLength(bgrDataByteArray);
|
|
if (isRgb) {
|
env->GetByteArrayRegion(bgrDataByteArray, 0, len,
|
reinterpret_cast<jbyte *>(main::rgbBuffer));
|
int face_nums = THFI_DetectFace(0, main::rgbBuffer, 24, width, height, main::rgbFps1, 10,
|
360);
|
int featureCount = 0;
|
for (int i = 0; i < face_nums; i++) {
|
try {
|
THFI_FacePos fps;
|
fps = main::rgbFps1[i];
|
ScoredRect scoredRect{fps.fAngle.confidence, {
|
fps.rcFace.left,
|
fps.rcFace.top,
|
fps.rcFace.right,
|
fps.rcFace.bottom
|
}, -1, map<string, string>()};
|
bool not_duplicate = main::trackingTrigger.triggerOnce(scoredRect);
|
bool track_id_changed = (main::track_id[i] != scoredRect.id);
|
main::track_id[i] = scoredRect.id;
|
if (main::track_id[i] == 1) {
|
int m = 0;
|
}
|
if (main::track_id[i] == -1) {
|
continue;
|
}
|
int liveness = 0;
|
main::liveness[i] = liveness;
|
int featureId = i;
|
double d1 = main::msecond();
|
if ((track_id_changed ||
|
(main::msecond() - main::prevExtractFeatureTime) > 2 * 1000)
|
&& shouldExtractFeature > 0) {
|
memset(main::features[i], 0, main::featureSize);
|
int ret = EF_Extract(0, main::rgbBuffer, width, height, 3, main::rgbFps1,
|
main::features[i]);
|
if (ret == 1) {
|
featureCount++;
|
main::prevExtractFeatureTime = main::msecond();
|
} else {
|
featureId = -1;
|
}
|
}
|
|
jclass facePositionClass = env->FindClass("com/basic/security/utils/FacePosition");
|
jmethodID facePositionClassMethodID = env->GetMethodID(facePositionClass, "<init>",
|
"(I)V");
|
jobject facePositionObject = env->NewObject(facePositionClass,
|
facePositionClassMethodID, 5);
|
|
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
}
|
setIntValue(env, detectedResult, "featureCount", featureCount);
|
} else {
|
env->GetByteArrayRegion(bgrDataByteArray, 0, len,
|
reinterpret_cast<jbyte *>(main::grayBuffer));
|
int face_nums = THFI_DetectFace(0, main::grayBuffer, 24, width, height, main::grayFps1, 10,
|
360);
|
}
|
int i = 10;
|
}
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_rgbDetectFace(
|
JNIEnv *env, jobject, jstring jModelPath, jstring jRgbFileName, jint width, int height,
|
jstring baseFeatureName, int shouldExtractFeature, bool useGrayCamera,
|
int detectFaceCount) {
|
string faces = FaceDetectHelper::getInstance()->detectRealFace(
|
env->GetStringUTFChars(jModelPath, 0), env->GetStringUTFChars(jRgbFileName, 0), nullptr,
|
width, height, env->GetStringUTFChars(baseFeatureName, 0), shouldExtractFeature,
|
useGrayCamera, detectFaceCount);
|
LogUtil::log(faces);
|
return env->NewStringUTF(faces.c_str());
|
}
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_rgbDetectFace2(
|
JNIEnv *env, jobject, jstring jModelPath, jstring jRgbFileName, jint width, int height,
|
jstring baseFeatureName, int shouldExtractFeature, bool useGrayCamera,
|
int detectFaceCount, jbyteArray bgrArray) {
|
string faces = FaceDetectHelper::getInstance()->detectRealFace2(env,
|
env->GetStringUTFChars(jModelPath, 0), env->GetStringUTFChars(jRgbFileName, 0), nullptr,
|
width, height, env->GetStringUTFChars(baseFeatureName, 0), shouldExtractFeature,
|
useGrayCamera, detectFaceCount, bgrArray);
|
LogUtil::log(faces);
|
return env->NewStringUTF(faces.c_str());
|
}
|
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_rgbDetectFace4(
|
JNIEnv *env, jobject,jint channel, jstring jModelPath, jstring jRgbFileName, jint width, int height,
|
jstring baseFeatureName, int shouldExtractFeature, bool useGrayCamera,
|
int detectFaceCount, jbyteArray bgrArray) {
|
string faces = FaceDetectHelper::getInstance()->detectRealFace4(env,
|
channel, env->GetStringUTFChars(jModelPath, 0), env->GetStringUTFChars(jRgbFileName, 0), nullptr,
|
width, height, env->GetStringUTFChars(baseFeatureName, 0), shouldExtractFeature,
|
useGrayCamera, detectFaceCount, bgrArray);
|
LogUtil::log(faces);
|
return env->NewStringUTF(faces.c_str());
|
}
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_rgbDetectFace3(
|
JNIEnv *env, jobject, jint channel, jstring jModelPath, jint width, int height,
|
jstring baseFeatureName, int shouldExtractFeature, bool useGrayCamera,
|
int detectFaceCount, jbyteArray nv21Array) {
|
string faces = FaceDetectHelper::getInstance()->detectRealFace3(channel, env,
|
env->GetStringUTFChars(jModelPath, 0),
|
width, height, env->GetStringUTFChars(baseFeatureName, 0), shouldExtractFeature,
|
useGrayCamera, detectFaceCount, nv21Array);
|
LogUtil::log(faces);
|
return env->NewStringUTF(faces.c_str());
|
}
|
|
extern "C" JNIEXPORT jbyteArray
|
JNICALL
|
Java_com_basic_security_utils_FaceId_extractFeature(
|
JNIEnv *env, jobject, jstring jpgFileName) {
|
return FaceDetectHelper::getInstance()->extractFeature(env,
|
env->GetStringUTFChars(jpgFileName, 0));
|
}
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_facePosition(
|
JNIEnv *env, jobject, jstring jpgFileName) {
|
string facePosition = FaceDetectHelper::getInstance()->facePosition(env,
|
env->GetStringUTFChars(jpgFileName, 0));
|
return env->NewStringUTF(facePosition.c_str());
|
}
|
|
extern "C" JNIEXPORT jbyteArray
|
JNICALL
|
Java_com_basic_security_utils_FaceId_extractFeature1(
|
JNIEnv *env, jobject, jbyteArray bgrByteArray, int width, int height) {
|
return FaceDetectHelper::getInstance()->extractFeature(env, bgrByteArray, width, height);
|
}
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_grayDetectFace(
|
JNIEnv *env, jobject, jstring jModelPath, jstring jGrayFileName, jint width, int height,
|
int detectFaceCount) {
|
string faces = FaceDetectHelper::getInstance()->detectRealFace(
|
env->GetStringUTFChars(jModelPath, 0), nullptr,
|
env->GetStringUTFChars(jGrayFileName, 0), width, height,
|
nullptr, 0, false, detectFaceCount);
|
LogUtil::log(faces);
|
return env->NewStringUTF(faces.c_str());
|
}
|
|
extern "C" JNIEXPORT void
|
JNICALL
|
Java_com_basic_security_utils_FaceId_cropFace(
|
JNIEnv *env, jobject, jstring frameJpgPath, jstring faceJpgPath, int width, int height,
|
int x1, int y1, int x2, int y2) {
|
try {
|
cv::Mat img = cv::imread(env->GetStringUTFChars(frameJpgPath, 0));
|
if (!img.empty()) {
|
/*cv::Rect roi;
|
roi.x = x1;
|
roi.y = y1;
|
roi.width = x2 - x1;
|
roi.height = y2 - y1;
|
cv::Mat crop = img(roi);
|
//env->GetStringUTFChars(faceJpgPath, 0)
|
cv::String name;
|
cv::imwrite(name, crop);
|
*/
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
}
|
|
jbyteArray as_byte_array(JNIEnv *env, unsigned char *buf, int len) {
|
jbyteArray array = env->NewByteArray(len);
|
env->SetByteArrayRegion(array, 0, len, reinterpret_cast<jbyte *>(buf));
|
return array;
|
}
|
|
unsigned char *as_unsigned_char_array(JNIEnv *env, jbyteArray array) {
|
int len = env->GetArrayLength(array);
|
unsigned char *buf = new unsigned char[len];
|
env->GetByteArrayRegion(array, 0, len, reinterpret_cast<jbyte *>(buf));
|
return buf;
|
}
|
|
unordered_map<string, shared_ptr<vector<unsigned char>>> featureMap;
|
list<pair<string, shared_ptr<vector<unsigned char>>>> featureList;
|
|
unordered_map<string, shared_ptr<vector<unsigned char>>> allFeatureMap;
|
|
extern "C" JNIEXPORT void
|
JNICALL
|
Java_com_basic_security_utils_FaceId_addFeatureToDb(
|
JNIEnv *env, jobject, jstring id, jbyteArray featureBuffer) {
|
try {
|
if (featureBuffer == nullptr) {
|
return;
|
}
|
if (featureMap.size() < 100 || 1 == 1) {
|
if (!useFeatureList) {
|
unsigned int max_size = featureMap.max_size();
|
{
|
int len = env->GetArrayLength(featureBuffer);
|
shared_ptr<vector<unsigned char>> feature = make_shared<vector<unsigned char>>(len);
|
env->GetByteArrayRegion(featureBuffer, 0, len,
|
reinterpret_cast<jbyte *>(feature.get()->data()));
|
const char *sid = env->GetStringUTFChars(id, 0);
|
featureMap[sid] = feature;
|
}
|
}
|
if (useFeatureList) {
|
unsigned int max_size = featureMap.max_size();
|
{
|
int len = env->GetArrayLength(featureBuffer);
|
shared_ptr<vector<unsigned char>> feature = make_shared<vector<unsigned char>>(len);
|
env->GetByteArrayRegion(featureBuffer, 0, len,
|
reinterpret_cast<jbyte *>(feature.get()->data()));
|
const char *sid = env->GetStringUTFChars(id, 0);
|
featureListMutex.lock();
|
featureList.push_back({sid, feature});
|
featureListMutex.unlock();
|
}
|
}
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
}
|
|
|
extern "C" JNIEXPORT void
|
JNICALL
|
Java_com_basic_security_utils_FaceId_addFeatureToAllDb(
|
JNIEnv *env, jobject, jstring id, jbyteArray featureBuffer) {
|
try {
|
if (featureBuffer == nullptr) {
|
return;
|
}
|
if (allFeatureMap.size() < 100 || 1 == 1) {
|
if (!useFeatureList) {
|
unsigned int max_size = allFeatureMap.max_size();
|
{
|
int len = env->GetArrayLength(featureBuffer);
|
shared_ptr<vector<unsigned char>> feature = make_shared<vector<unsigned char>>(len);
|
env->GetByteArrayRegion(featureBuffer, 0, len,
|
reinterpret_cast<jbyte *>(feature.get()->data()));
|
const char *sid = env->GetStringUTFChars(id, 0);
|
allFeatureMap[sid] = feature;
|
}
|
}
|
/*if (useFeatureList) {
|
unsigned int max_size = allFeatureMap.max_size();
|
{
|
int len = env->GetArrayLength(featureBuffer);
|
shared_ptr<vector<unsigned char>> feature = make_shared<vector<unsigned char>>(len);
|
env->GetByteArrayRegion(featureBuffer, 0, len,
|
reinterpret_cast<jbyte *>(feature.get()->data()));
|
const char *sid = env->GetStringUTFChars(id, 0);
|
featureListMutex.lock();
|
featureList.push_back({sid, feature});
|
featureListMutex.unlock();
|
}
|
}*/
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
}
|
|
|
unordered_map<string, shared_ptr<vector<unsigned char>>> tempFeatureMap;
|
list<pair<string, shared_ptr<vector<unsigned char>>>> tempFeatureList;
|
|
extern "C" JNIEXPORT void
|
JNICALL
|
Java_com_basic_security_utils_FaceId_addFeatureToTempDb(
|
JNIEnv *env, jobject, jstring id, jbyteArray featureBuffer) {
|
try {
|
if (tempFeatureMap.size() < 100 || 1 == 1) {
|
if (!useFeatureList) {
|
unsigned int max_size = tempFeatureMap.max_size();
|
{
|
int len = env->GetArrayLength(featureBuffer);
|
shared_ptr<vector<unsigned char>> feature = make_shared<vector<unsigned char>>(len);
|
env->GetByteArrayRegion(featureBuffer, 0, len,
|
reinterpret_cast<jbyte *>(feature.get()->data()));
|
const char *sid = env->GetStringUTFChars(id, 0);
|
tempFeatureMap[sid] = feature;
|
}
|
} else {
|
unsigned int max_size = tempFeatureMap.max_size();
|
{
|
int len = env->GetArrayLength(featureBuffer);
|
shared_ptr<vector<unsigned char>> feature = make_shared<vector<unsigned char>>(len);
|
env->GetByteArrayRegion(featureBuffer, 0, len,
|
reinterpret_cast<jbyte *>(feature.get()->data()));
|
const char *sid = env->GetStringUTFChars(id, 0);
|
tempFeatureLock.lock();
|
tempFeatureList.push_front({sid, feature});
|
tempFeatureLock.unlock();
|
}
|
}
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
}
|
|
extern "C" JNIEXPORT jfloat
|
JNICALL
|
Java_com_basic_security_utils_FaceId_compareFeature(
|
JNIEnv *env, jobject, jbyteArray featureBuffer1, jbyteArray featureBuffer2) {
|
float score = 0;
|
try {
|
if (!featureBuffer1 || !featureBuffer2) {
|
return score;
|
}
|
unsigned char *buf1 = as_unsigned_char_array(env, featureBuffer1);
|
unsigned char *buf2 = as_unsigned_char_array(env, featureBuffer2);
|
score = EF_Compare(buf1, buf2)*100;
|
delete[] buf1;
|
delete[] buf2;
|
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
return score;
|
}
|
|
|
unsigned char buf[2560];
|
|
void
|
moveToFront(
|
std::list<pair<string, shared_ptr<vector<unsigned char>>>>& list,
|
std::list<pair<string, shared_ptr<vector<unsigned char>>>>::iterator element )
|
{
|
if ( element != list.begin() ) {
|
list.splice( list.begin(), list, element, std::next( element ) );
|
}
|
}
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_compareFeatureInDb(
|
JNIEnv *env, jobject, jbyteArray featureBuffer, jint minScore) {
|
float score = 0;
|
string result = ",0";
|
try {
|
env->GetByteArrayRegion(featureBuffer, 0, 2560, reinterpret_cast<jbyte *>(buf));
|
if (!useFeatureList) {
|
for (auto const &featureItem : featureMap) {
|
string id = featureItem.first;
|
unsigned char *data = featureItem.second.get()->data();
|
printf("%s\n", id.c_str());
|
score = EF_Compare(buf, data)*100;
|
int i = 10;
|
if (score >= minScore) {
|
// LOGI("the score is :%d",score);
|
result = "";
|
result.append(id);
|
result.append(",");
|
result.append(to_string(score));
|
break;
|
}
|
}
|
} else {
|
featureListMutex.lock();
|
for (auto featureItem = begin(featureList); featureItem != end(featureList); featureItem++) {
|
string id = featureItem->first;
|
unsigned char *data = featureItem->second.get()->data();
|
printf("%s\n", id.c_str());
|
score = EF_Compare(buf, data)*100;
|
int i = 10;
|
if (score >= minScore) {
|
// LOGI("the score is :%d",score);
|
moveToFront(featureList, featureItem);
|
result = "";
|
result.append(id);
|
result.append(",");
|
result.append(to_string(score));
|
break;
|
}
|
}
|
featureListMutex.unlock();
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
return env->NewStringUTF(result.c_str());
|
}
|
|
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_compareFeatureInAllDb(
|
JNIEnv *env, jobject, jbyteArray featureBuffer, jint minScore) {
|
float score = 0;
|
string result = ",0";
|
try {
|
env->GetByteArrayRegion(featureBuffer, 0, 2560, reinterpret_cast<jbyte *>(buf));
|
if (!useFeatureList) {
|
for (auto const &featureItem : allFeatureMap) {
|
string id = featureItem.first;
|
unsigned char *data = featureItem.second.get()->data();
|
printf("%s\n", id.c_str());
|
score = EF_Compare(buf, data)*100;
|
int i = 10;
|
if (score >= minScore) {
|
result = "";
|
result.append(id);
|
result.append(",");
|
result.append(to_string(score));
|
break;
|
}
|
}
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
return env->NewStringUTF(result.c_str());
|
}
|
|
|
unsigned char tempFeatureBuf[2560];
|
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_compareFeatureInTempDb(
|
JNIEnv *env, jobject, jbyteArray featureBuffer, jint minScore) {
|
float score = 0;
|
string result = ",0";
|
try {
|
env->GetByteArrayRegion(featureBuffer, 0, 2560, reinterpret_cast<jbyte *>(tempFeatureBuf));
|
if (!useFeatureList) {
|
for (auto const &featureItem : tempFeatureMap) {
|
string id = featureItem.first;
|
unsigned char *data = featureItem.second.get()->data();
|
printf("%s\n", id.c_str());
|
score = EF_Compare(tempFeatureBuf, data)*100;
|
int i = 10;
|
if (score >= minScore) {
|
// LOGI("the score is :%d",score);
|
result = "";
|
result.append(id);
|
result.append(",");
|
result.append(to_string(score));
|
break;
|
}
|
}
|
} else {
|
tempFeatureLock.lock();
|
for (auto featureItem = begin(tempFeatureList); featureItem != end(tempFeatureList); featureItem++) {
|
string id = featureItem->first;
|
unsigned char *data = featureItem->second.get()->data();
|
printf("%s\n", id.c_str());
|
score = EF_Compare(tempFeatureBuf, data)*100;
|
int i = 10;
|
if (score >= minScore) {
|
// LOGI("the score is :%d",score);
|
moveToFront(tempFeatureList, featureItem);
|
result = "";
|
result.append(id);
|
result.append(",");
|
result.append(to_string(score));
|
break;
|
}
|
}
|
tempFeatureLock.unlock();
|
}
|
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
return env->NewStringUTF(result.c_str());
|
}
|
|
|
extern "C" JNIEXPORT void
|
JNICALL
|
Java_com_basic_security_utils_FaceId_removeFeatureFromTempDb(JNIEnv *env, jobject, jstring id) {
|
try {
|
if (!useFeatureList) {
|
tempFeatureMap.erase(env->GetStringUTFChars(id, 0));
|
} else {
|
auto personId = env->GetStringUTFChars(id, 0);
|
tempFeatureLock.lock();
|
for (auto it = begin(tempFeatureList); it != end(tempFeatureList); it++) {
|
if (it->first == personId) {
|
// tempFeatureList.remove(*it);
|
printf("tempFeatureList1 before %d\n", tempFeatureList.size());
|
tempFeatureList.erase(it);
|
printf("tempFeatureList1 end %d\n", tempFeatureList.size());
|
break;
|
}
|
}
|
tempFeatureLock.unlock();
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
}
|
|
extern "C" JNIEXPORT void
|
JNICALL
|
Java_com_basic_security_utils_FaceId_removeFeatureFromDb(JNIEnv *env, jobject, jstring id) {
|
try {
|
if (!useFeatureList) {
|
featureMap.erase(env->GetStringUTFChars(id, 0));
|
} else {
|
auto personId = env->GetStringUTFChars(id, 0);
|
featureListMutex.lock();
|
for (auto it = begin(featureList); it != end(featureList); it++) {
|
if (it->first == personId) {
|
printf("featureList erase before %d\n", featureList.size());
|
featureList.erase(it);
|
printf("featureList erase end %d\n", featureList.size());
|
break;
|
}
|
}
|
featureListMutex.unlock();
|
}
|
} catch (exception &e) {
|
LogUtil::log(e.what());
|
}
|
}
|
|
//static double r2d(AVRational r) {
|
// return r.num == 0 || r.den == 0 ? 0 : (double) r.num / (double) r.den;
|
//}
|
|
//当前时间戳 clock
|
long long GetNowMs() {
|
struct timeval tv;
|
gettimeofday(&tv, NULL);
|
int sec = tv.tv_sec % 360000;
|
long long t = sec * 1000 + tv.tv_usec / 1000;
|
return t;
|
}
|
|
extern "C"
|
JNIEXPORT
|
jint JNI_OnLoad(JavaVM *vm, void *res) {
|
//av_jni_set_java_vm(vm, 0);
|
return JNI_VERSION_1_4;
|
}
|
|
|
extern "C"
|
JNIEXPORT void JNICALL
|
Java_com_basic_security_widget_H264Player_Open(JNIEnv *env, jobject instance, jstring url_,
|
jobject surface) {
|
const char *path = env->GetStringUTFChars(url_, 0);
|
// av_register_all();
|
// avformat_network_init();
|
// avcodec_register_all();
|
// AVFormatContext *ic = NULL;
|
// int re = avformat_open_input(&ic, path, 0, 0);
|
// if (re != 0) { return; }
|
// re = avformat_find_stream_info(ic, 0);
|
// if (re != 0) {}
|
// int fps = 0;
|
// int videoStream = 0;
|
// int audioStream = 1;
|
// for (int i = 0; i < ic->nb_streams; i++) {
|
// AVStream *as = ic->streams[i];
|
// if (as->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
|
// videoStream = i;
|
// fps = r2d(as->avg_frame_rate);
|
// } else if (as->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
|
// audioStream = i;
|
// }
|
// }
|
// audioStream = av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
|
//
|
// AVCodec *codec = avcodec_find_decoder(ic->streams[videoStream]->codecpar->codec_id);
|
// codec = avcodec_find_decoder_by_name("h264_mediacodec");
|
// if (!codec) { return; }
|
// AVCodecContext *vc = avcodec_alloc_context3(codec);
|
// avcodec_parameters_to_context(vc, ic->streams[videoStream]->codecpar);
|
// vc->thread_count = 8;
|
// re = avcodec_open2(vc, 0, 0);
|
// if (re != 0) { return; }
|
// AVPacket *pkt = av_packet_alloc();
|
// AVFrame *frame = av_frame_alloc();
|
// long long start = GetNowMs();
|
// int frameCount = 0;
|
// SwsContext *vctx = NULL;
|
// int outWidth = 640;
|
// int outHeight = 480;
|
// char *rgb = new char[1920 * 1080 * 4];
|
// char *pcm = new char[48000 * 4 * 2];
|
// ANativeWindow *nwin = ANativeWindow_fromSurface(env, surface);
|
// ANativeWindow_setBuffersGeometry(nwin, outWidth, outHeight, WINDOW_FORMAT_RGBA_8888);
|
// ANativeWindow_Buffer wbuf;
|
//
|
// for (;;) {
|
// if (GetNowMs() - start >= 3000) {
|
// start = GetNowMs();
|
// frameCount = 0;
|
// }
|
//
|
// int re = av_read_frame(ic, pkt);
|
// if (re != 0) {
|
// int pos = 20 * r2d(ic->streams[videoStream]->time_base);
|
// av_seek_frame(ic, videoStream, pos, AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_FRAME);
|
// continue;
|
// }
|
// AVCodecContext *cc = vc;
|
// re = avcodec_send_packet(cc, pkt);
|
// //清理
|
// int p = pkt->pts;
|
// av_packet_unref(pkt);
|
// if (re != 0) {
|
// continue;
|
// }
|
// for (;;) {
|
// re = avcodec_receive_frame(cc, frame);
|
// if (re != 0) {
|
// break;
|
// }
|
// if (cc == vc) {
|
// frameCount++;
|
// vctx = sws_getCachedContext(vctx,
|
// frame->width,
|
// frame->height,
|
// (AVPixelFormat) frame->format,
|
// outWidth,
|
// outHeight,
|
// AV_PIX_FMT_RGBA,
|
// SWS_FAST_BILINEAR,
|
// 0, 0, 0
|
// );
|
// if (!vctx) {}
|
// else {
|
// uint8_t *data[AV_NUM_DATA_POINTERS] = {0};
|
// data[0] = (uint8_t *) rgb;
|
// int lines[AV_NUM_DATA_POINTERS] = {0};
|
// lines[0] = outWidth * 4;
|
// int h = sws_scale(vctx,
|
// (const uint8_t **) frame->data,
|
// frame->linesize, 0,
|
// frame->height,
|
// data, lines);
|
//// LOGW("sws_scale = %d",h);
|
// if (h > 0) {
|
// ofstream ofs;
|
// ofs.open("/sdcard/ffmpeg.rgb", ios::binary);
|
// ofs.write((char *) rgb, outWidth * outHeight * 4);
|
// ofs.close();
|
//
|
// ANativeWindow_lock(nwin, &wbuf, 0);
|
// uint8_t *dst = (uint8_t *) wbuf.bits;
|
// memcpy(dst, rgb, outWidth * outHeight * 4);
|
// ANativeWindow_unlockAndPost(nwin);
|
// }
|
// }
|
//
|
// } else {}
|
// }
|
// }
|
// delete rgb;
|
// delete pcm;
|
// avformat_close_input(&ic);
|
env->ReleaseStringUTFChars(url_, path);
|
|
}
|
|
|
unsigned char* readFileToByteArray(char* fileName, int* fsize) {
|
FILE *f = fopen(fileName, "rb");
|
fseek(f, 0, SEEK_END);
|
*fsize = ftell(f);
|
fseek(f, 0, SEEK_SET);
|
|
unsigned char * string = (unsigned char*)malloc(*fsize);
|
fread(string, *fsize, 1, f);
|
fclose(f);
|
return string;
|
|
}
|
|
void test () {
|
int nSize1;
|
char* sFile1;
|
readFileToByteArray(sFile1,&nSize1);
|
}
|
|
|
#define MAXRECVSTRING 255 /* Longest string to receive */
|
|
void DieWithError(char *errorMessage) {
|
printf("%s\n", errorMessage);
|
} /* External error handling function */
|
|
#include <stdio.h> /* for printf() and fprintf() */
|
#include <sys/socket.h> /* for socket(), connect(), sendto(), and recvfrom() */
|
#include <arpa/inet.h> /* for sockaddr_in and inet_addr() */
|
#include <stdlib.h> /* for atoi() and exit() */
|
#include <string.h> /* for memset() */
|
#include <unistd.h> /* for close() */
|
|
|
bool receiveBroadcastFirst = true;
|
|
int sock;
|
struct sockaddr_in broadcastAddr; /* Broadcast Address */
|
char recvString[MAXRECVSTRING+1]; /* Buffer for received string */
|
extern "C" JNIEXPORT jstring
|
JNICALL
|
Java_com_basic_security_utils_FaceId_receiveBroadcast(JNIEnv *env, jobject, jchar broadcastPort1) { /* Socket */
|
|
unsigned short broadcastPort = broadcastPort1; /* Port */
|
|
int recvStringLen; /* Length of received string */
|
|
if (receiveBroadcastFirst) {
|
/* Create a best-effort datagram socket using UDP */
|
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
|
DieWithError("socket() failed");
|
|
/* Construct bind structure */
|
memset(&broadcastAddr, 0, sizeof(broadcastAddr)); /* Zero out structure */
|
broadcastAddr.sin_family = AF_INET; /* Internet address family */
|
broadcastAddr.sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */
|
broadcastAddr.sin_port = htons(broadcastPort); /* Broadcast port */
|
|
/* Bind to the broadcast port */
|
if (::bind(sock, (struct sockaddr *) &broadcastAddr, sizeof(broadcastAddr)) < 0)
|
DieWithError("bind() failed");
|
receiveBroadcastFirst = false;
|
}
|
|
|
/* Receive a single datagram from the server */
|
if ((recvStringLen = recvfrom(sock, recvString, MAXRECVSTRING, 0, NULL, 0)) < 0)
|
DieWithError("recvfrom() failed");
|
|
recvString[recvStringLen] = '\0';
|
printf("Received: %s\n", recvString); /* Print the received string */
|
|
// close(sock);
|
// exit(0);
|
return env->NewStringUTF(recvString);
|
|
}
|
