#include <MaterialBuffer.h>
|
#include <logger.h>
|
|
#include "ev_server.h"
|
#include "ev_proto.h"
|
#include "face_daemon_proto.h"
|
#include "sample_face_search.h"
|
#include "STFaceCache.h"
|
#include "PbFaceList.pb.h"
|
|
#include <signal.h>
|
|
#include <sstream>
|
#include <iostream>
|
|
#define WRAPPER_TEXT(x) "\"" << x << "\""
|
|
Logger g_logger(std::cout);
|
STFaceCache g_STFaceCache("/opt/FaceServer/stfacedb");
|
|
evclient_proc_t evclient_proc;
|
|
void _sigint(int sign_no)
|
{
|
server_stop();
|
}
|
|
bool send_SensetimeFaceDetectResultJson(EVClientStub& client, const fdr_vec_t& result, int ret = 0)
|
{
|
std::stringstream ss;
|
ss << "{" << LOG_ENDL;
|
ss << "\"ret\":" << WRAPPER_TEXT(ret) << "," << LOG_ENDL;
|
ss << "\"count\":" << WRAPPER_TEXT(result.size()) << "," << LOG_ENDL;
|
ss << "\"result\":[";
|
for(fdr_vec_t::const_iterator iter = result.begin(); iter != result.end(); ++iter)
|
{
|
ss << "[" << WRAPPER_TEXT(iter->db_id) << ","
|
<< WRAPPER_TEXT(iter->st_id) << ","
|
<< WRAPPER_TEXT(iter->confidence) << ","
|
<< WRAPPER_TEXT(iter->camera_id) << ","
|
<< WRAPPER_TEXT(iter->st_track_id) << "]";
|
if (iter != std::prev(result.end()))
|
ss << ",";
|
}
|
ss << "]" << LOG_ENDL;
|
ss << "}";
|
|
std::string output(ss.str());//#todo avoid copy
|
client.sendBuffSize = output.size();
|
client.sendBuff = new uint8_t[output.size() + 1];
|
strcpy((char*)client.sendBuff, output.c_str());
|
client.deleteSendBuff = true;
|
|
LOG_DEBUG << (char*)client.sendBuff << LOG_ENDL;
|
|
return true;
|
}
|
|
bool ev_proc_SensetimeFaceDetectPB(EVClientStub& client)
|
{
|
//#test send //00038300FE4B0000+pb
|
//EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
//LOG_DEBUG << "cmd=" << evpHeader->cmd << ", size=" << evpHeader->size << ", \t" << (char*)(evpHeader + sizeof(EVPHeader)) << LOG_ENDL;
|
//return true;
|
|
EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
FDP_FaceDetectPB* fdpFaceDetectPB = (FDP_FaceDetectPB*)(client.recvBuff + sizeof(EVPHeader));
|
fdpFaceDetectPB->ntoh();
|
|
PbFaceList pbFaceList;
|
pbFaceList.ParseFromArray(client.recvBuff + sizeof(EVPHeader) + sizeof(FDP_FaceDetectPB), evpHeader->size - sizeof(EVPHeader) - sizeof(FDP_FaceDetectPB));
|
LOGP(DEBUG, "pbFaceList: magic=%u, image_count=%u, src_width=%u, src_height=%u",
|
pbFaceList.magic(), pbFaceList.image_count(), pbFaceList.src_width(), pbFaceList.src_height());
|
|
fdr_vec_t result;
|
|
for(int i = 0; i < pbFaceList.image_count(); i++)
|
{
|
const PbFaceList_FaceListImage& pbFaceListImage = pbFaceList.images(i);
|
LOGP(DEBUG, "\tpbFaceList %d: idx=%u, size=%u, type=%u, width=%u, height=%u, top_left_x=%u, top_left_y=%u",
|
i, pbFaceListImage.idx(), pbFaceListImage.size(), pbFaceListImage.type(), pbFaceListImage.width(), pbFaceListImage.height(), pbFaceListImage.top_left_x(), pbFaceListImage.top_left_y());
|
|
//#test
|
//char imgfn[100 * 1024];
|
//sprintf(imgfn, "PB_%d_%d.yuv", 0, i);
|
//
|
//FILE * pFile = fopen(imgfn, "wb");
|
const std::string* img(*pbFaceListImage.img().data());
|
//fwrite(img->data(), sizeof(char), img->size(), pFile);
|
//fclose(pFile);
|
//pFile = nullptr;
|
|
STFaceImage stimg;
|
stimg.db_id = fdpFaceDetectPB->db_id;
|
stimg.mb_type = pbFaceListImage.type();
|
stimg.width = pbFaceListImage.width();
|
stimg.height = pbFaceListImage.height();
|
stimg.size = img->size();
|
stimg.buff = (const uint8_t*)img->data();
|
|
FDP_FaceDetectResult res(g_STFaceCache.detect(stimg));
|
|
#ifdef ENABLE_ADD_TO_TEMPDB_WHEN_NOT_DETECT
|
if (res.db_id == STFS_DBID_INVALID)
|
{
|
// #todo optimize extract feature once
|
stimg.db_id = STFS_DBID_TEMPDB_1;
|
res = g_STFaceCache.add(stimg);
|
}
|
#endif
|
|
res.camera_id = fdpFaceDetectPB->camera_id;
|
res.st_track_id = pbFaceListImage.st_track_id();
|
result.push_back(res);
|
}
|
|
//#test
|
//result.push_back(FDP_FaceDetectResult(-1,123));
|
//result.push_back(FDP_FaceDetectResult(2,456));
|
//result.push_back(FDP_FaceDetectResult(0,0));
|
|
return send_SensetimeFaceDetectResultJson(client, result);
|
}
|
|
bool ev_proc_SensetimeFaceDetectSave(EVClientStub& client)
|
{
|
EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
FDP_Image* fdpImage = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader));
|
fdpImage->ntoh();
|
|
STFaceImage stfaceImg;
|
stfaceImg.db_id = fdpImage->db_id;
|
stfaceImg.mb_type = fdpImage->mb_type;
|
stfaceImg.width = fdpImage->width;
|
stfaceImg.height = fdpImage->height;
|
stfaceImg.size = evpHeader->size - sizeof(EVPHeader) - sizeof(FDP_Image);
|
stfaceImg.buff = fdpImage->buff;
|
|
LOGP(DEBUG, "stfaceImg db_id=%d, mb_type=%d, width=%d, height=%d, size=%d",
|
(int)stfaceImg.db_id, (int)stfaceImg.mb_type, (int)stfaceImg.width, (int)stfaceImg.height, (int)stfaceImg.size);
|
|
//char imgfn[100 * 1024];
|
//static int i = 0;
|
//sprintf(imgfn, "IMG_%d_%d_w%d_h%d.rgb565", stfaceImg.db_id, ++i, stfaceImg.width, stfaceImg.height);
|
//FILE * pFile = fopen(imgfn, "wb");
|
//fwrite(stfaceImg.buff, sizeof(char), stfaceImg.size, pFile);
|
//fclose(pFile);
|
//pFile = nullptr;
|
|
fdr_vec_t result;
|
FDP_FaceDetectResult fdrResult = g_STFaceCache.add(stfaceImg);
|
result.push_back(fdrResult);
|
|
int ret = (fdrResult.db_id == 0 ? -1 : 0);
|
return send_SensetimeFaceDetectResultJson(client, result, ret);
|
}
|
|
bool ev_proc_SensetimeFaceDetectCompare(EVClientStub& client)
|
{
|
EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
|
FDP_Image* fdpImage1 = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader));
|
fdpImage1->ntoh();
|
|
STFaceImage stfaceImg1;
|
stfaceImg1.db_id = fdpImage1->db_id;
|
stfaceImg1.mb_type = fdpImage1->mb_type;
|
stfaceImg1.width = fdpImage1->width;
|
stfaceImg1.height = fdpImage1->height;
|
stfaceImg1.size = fdpImage1->size;
|
stfaceImg1.buff = fdpImage1->buff;
|
|
LOGP(DEBUG, "stfaceImg1 db_id=%d, mb_type=%d, width=%d, height=%d, size=%d",
|
(int)stfaceImg1.db_id, (int)stfaceImg1.mb_type, (int)stfaceImg1.width, (int)stfaceImg1.height, (int)stfaceImg1.size);
|
|
FDP_Image* fdpImage2 = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader) + sizeof(FDP_Image) + fdpImage1->size);
|
fdpImage2->ntoh();
|
|
STFaceImage stfaceImg2;
|
stfaceImg2.db_id = fdpImage2->db_id;
|
stfaceImg2.mb_type = fdpImage2->mb_type;
|
stfaceImg2.width = fdpImage2->width;
|
stfaceImg2.height = fdpImage2->height;
|
stfaceImg2.size = fdpImage2->size;
|
stfaceImg2.buff = fdpImage2->buff;
|
|
LOGP(DEBUG, "stfaceImg2 db_id=%d, mb_type=%d, width=%d, height=%d, size=%d",
|
(int)stfaceImg2.db_id, (int)stfaceImg2.mb_type, (int)stfaceImg2.width, (int)stfaceImg2.height, (int)stfaceImg2.size);
|
|
//char imgfn[100 * 1024];
|
//static int i = 0;
|
//sprintf(imgfn, "IMG_%d_%d_w%d_h%d.img", stfaceImg1.db_id, ++i, stfaceImg1.width, stfaceImg1.height);
|
//FILE * pFile = fopen(imgfn, "wb");
|
//fwrite(stfaceImg1.buff, sizeof(char), stfaceImg1.size, pFile);
|
//fclose(pFile);
|
//pFile = nullptr;
|
//
|
//sprintf(imgfn, "IMG_%d_%d_w%d_h%d.img", stfaceImg2.db_id, ++i, stfaceImg2.width, stfaceImg2.height);
|
//pFile = fopen(imgfn, "wb");
|
//fwrite(stfaceImg2.buff, sizeof(char), stfaceImg2.size, pFile);
|
//fclose(pFile);
|
//pFile = nullptr;
|
|
fdr_vec_t result;
|
FDP_FaceDetectResult fdrResult = g_STFaceCache.compare(stfaceImg1, stfaceImg2);
|
result.push_back(fdrResult);
|
|
return send_SensetimeFaceDetectResultJson(client, result, 0);
|
}
|
|
bool ev_proc_SensetimeFaceDetectSearch(EVClientStub& client)
|
{
|
EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
FDP_Image* fdpImage = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader));
|
fdpImage->ntoh();
|
|
STFaceImage stfaceImg;
|
stfaceImg.db_id = fdpImage->db_id;
|
stfaceImg.mb_type = fdpImage->mb_type;
|
stfaceImg.width = fdpImage->width;
|
stfaceImg.height = fdpImage->height;
|
stfaceImg.size = evpHeader->size - sizeof(EVPHeader) - sizeof(FDP_Image);
|
stfaceImg.buff = fdpImage->buff;
|
|
LOGP(DEBUG, "stfaceImg db_id=%d, mb_type=%d, width=%d, height=%d, size=%d",
|
(int)stfaceImg.db_id, (int)stfaceImg.mb_type, (int)stfaceImg.width, (int)stfaceImg.height, (int)stfaceImg.size);
|
|
|
char imgfn[100 * 1024];
|
static int i = 0;
|
sprintf(imgfn, "IMG_%d_%d_w%d_h%d.rgb565", stfaceImg.db_id, ++i, stfaceImg.width, stfaceImg.height);
|
FILE * pFile = fopen(imgfn, "wb");
|
fwrite(stfaceImg.buff, sizeof(char), stfaceImg.size, pFile);
|
fclose(pFile);
|
pFile = nullptr;
|
|
fdr_vec_t result;
|
g_STFaceCache.search(stfaceImg, result);
|
|
//int ret = (fdrResult.db_id == 0 ? -1 : 0);
|
return send_SensetimeFaceDetectResultJson(client, result, 0);
|
}
|
|
bool ev_dispatcher_proto_pb(EVClientStub& client)
|
{
|
LOG_DEBUG << "ev_dispatcher_proto_pb" << LOG_ENDL;
|
|
EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
if (evpHeader->size != client.recvBuffSize)
|
{
|
LOG_WARN << "Truncated buffer " << (evpHeader->size - client.recvBuffSize) << " bytes" << LOG_ENDL;
|
return false;
|
}
|
|
switch(evpHeader->cmd)
|
{
|
case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_PB:
|
//000383000800000001
|
return ev_proc_SensetimeFaceDetectPB(client);
|
break;
|
default:
|
LOG_WARN << "Unknown command" << LOG_ENDL;
|
ev_send_status_packet(client, EVPStatus::EVPS_COMMAND_ERROR);
|
return false;
|
break;
|
}
|
|
// return false to disconnect
|
return false;
|
}
|
|
bool ev_dispatcher_proto_rawbin(EVClientStub& client)
|
{
|
LOG_DEBUG << "ev_dispatcher_proto_rawbin" << LOG_ENDL;
|
|
EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
if (evpHeader->size != client.recvBuffSize)
|
{
|
LOG_WARN << "Truncated buffer " << (evpHeader->size - client.recvBuffSize) << " bytes" << LOG_ENDL;
|
return false;
|
}
|
|
switch(evpHeader->cmd)
|
{
|
case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_SAVE:
|
return ev_proc_SensetimeFaceDetectSave(client);
|
break;
|
case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_COMPARE:
|
return ev_proc_SensetimeFaceDetectCompare(client);
|
break;
|
case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_SEARCH:
|
return ev_proc_SensetimeFaceDetectSearch(client);
|
break;
|
default:
|
LOG_WARN << "Unknown command" << LOG_ENDL;
|
ev_send_status_packet(client, EVPStatus::EVPS_COMMAND_ERROR);
|
return false;
|
break;
|
}
|
|
// return false to disconnect
|
return false;
|
}
|
|
bool ev_dispatcher_proto(EVClientStub& client)
|
{
|
LOG_DEBUG << "ev_dispatcher_proto" << LOG_ENDL;
|
|
EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
|
if (evpHeader->size != client.recvBuffSize)
|
{
|
LOG_WARN << "Truncated buffer " << (evpHeader->size - client.recvBuffSize) << " bytes" << LOG_ENDL;
|
return false;
|
}
|
|
switch(evpHeader->proto)
|
{
|
case EVPProto::EVPP_PROTOBUF:
|
return ev_dispatcher_proto_pb(client);
|
break;
|
case EVPProto::EVPP_RAW_BIN:
|
return ev_dispatcher_proto_rawbin(client);
|
break;
|
default:
|
LOG_WARN << "Unknown proto" << LOG_ENDL;
|
ev_send_status_packet(client, EVPStatus::EVPS_PROTO_ERROR);
|
return false;
|
break;
|
}
|
|
// return false to disconnect
|
return false;
|
}
|
|
int main(int argc, char** argv)
|
{
|
g_logger.set_level(VERBOSE);
|
|
signal(SIGINT, _sigint);
|
|
if (!g_STFaceCache.init())
|
{
|
LOG_WARN << "g_STFaceCache.init return false" << LOG_ENDL;
|
return EXIT_FAILURE;
|
}
|
|
if (!g_STFaceCache.load_dbs())
|
{
|
LOG_WARN << "g_STFaceCache.load_dbs return false" << LOG_ENDL;
|
return EXIT_FAILURE;
|
}
|
|
evclient_proc = ev_dispatcher_proto;
|
int ec = server_main(argc, argv);
|
|
g_STFaceCache.close_dbs();
|
g_STFaceCache.finit();
|
|
return ec;
|
}
|
