From 068a0fd45a9802035119b6054f4c31cd19925b33 Mon Sep 17 00:00:00 2001
From: houxiao <houxiao@454eff88-639b-444f-9e54-f578c98de674>
Date: 星期三, 19 四月 2017 18:22:00 +0800
Subject: [PATCH] dev

---
 FaceServer/facelist-3.pb        |    0 
 FaceServer/make.sh              |   38 ++++
 FaceServer/main_face_daemon.cpp |  263 ++++++++++------------------
 FaceServer/ev_server.cpp        |   63 ++++--
 FaceServer/face_daemon_proto.h  |   48 +++++
 FaceServer/test_client.cpp      |   97 ++++++++++
 FaceServer/ev_proto.h           |   26 ++
 FaceServer/ev_server.h          |    1 
 8 files changed, 339 insertions(+), 197 deletions(-)

diff --git a/FaceServer/ev_proto.h b/FaceServer/ev_proto.h
index 6dc27be..2f1bed4 100644
--- a/FaceServer/ev_proto.h
+++ b/FaceServer/ev_proto.h
@@ -3,8 +3,22 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <limits.h>
 
 #pragma pack(1)
+
+struct EVPProto
+{
+	enum EVPP
+	{
+		EVPP__FIRST,
+		EVPP_RAW_BIN = 1,
+		EVPP_RAW_TEXT,
+		EVPP_PROTOBUF,
+		EVPP_HTTP,
+		EVPP__LAST
+	};
+};
 
 struct EVPCommand
 {
@@ -13,7 +27,7 @@
 		EVPC__FIRST,
 		EVPC_STATUS = 1,
 		EVPC_USER_DEFINE = 128,
-		EVPC__LAST
+		EVPC__LAST = USHRT_MAX
 	};
 };
 
@@ -25,6 +39,8 @@
 		EVPS_OK = 1,
 		EVPS_ERROR = 128,
 		EVPS_INTERNAL_ERROR,
+		EVPS_PROTO_ERROR,
+		EVPS_COMMAND_ERROR,
 		EVPS_PARAMETER_ERROR,
 		EVPS__LAST
 	};
@@ -32,8 +48,16 @@
 
 struct EVPHeader
 {
+private:
+	uint8_t _padding1;
+
+public:
+	uint8_t proto;  // EVPProto::EVPP
 	int16_t cmd;	// EVPCommand::EVPC
 	uint32_t size;	// sizeof(EVPHeader)+sizeof(subcmd)
+	
+	EVPHeader() : _padding1(0), proto(EVPProto::EVPP__FIRST), cmd(EVPCommand::EVPC__FIRST), size(8)
+	{}
 };
 
 struct EVP_Status
diff --git a/FaceServer/ev_server.cpp b/FaceServer/ev_server.cpp
index 2f423a2..4d5b29c 100644
--- a/FaceServer/ev_server.cpp
+++ b/FaceServer/ev_server.cpp
@@ -1,6 +1,6 @@
 #include "ev_server.h" 
 #include "ev_proto.h"
-#include "logger.h"
+#include <logger.h>
 
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -69,11 +69,11 @@
 	if (what & EVBUFFER_EOF)
 	{
 		//Client disconnected, remove the read event and the free the client structure.
-		LOG_INFO << "Client disconnected." << std::endl;
+		LOG_INFO << "Client disconnected." << LOG_ENDL;
 	}
 	else
 	{
-		LOG_WARN << "Client socket error, disconnecting." << std::endl;
+		LOG_WARN << "Client socket error, disconnecting." << LOG_ENDL;
 	}
 	bufferevent_free(client->buf_ev);
 	close(client->fd);
@@ -89,12 +89,12 @@
 	// Write back the read buffer. It is important to note that
 	// bufferevent_write_buffer will drain the incoming data so it
 	// is effectively gone after we call it.
-	//LOG_DEBUG << (char*)bufev->input << std::endl;
+	//LOG_DEBUG << (char*)bufev->input << LOG_ENDL;
 	//bufferevent_write_buffer(bufev, bufev->input);
 	
 	//char buff[100] = {'\0'};
 	//size_t readSize = bufferevent_read(bufev, buff, sizeof(buff));
-	//LOG_DEBUG << "readSize=" << readSize << "\t" << buff << std::endl;
+	//LOG_DEBUG << "readSize=" << readSize << "\t" << buff << LOG_ENDL;
 
 	EVPHeader* evpHeader = (EVPHeader*)client->recvbuff;
 	
@@ -107,7 +107,7 @@
 			client->read_times = 1;
 			if (readSize != sizeof(headerBuff))
 			{
-				LOG_WARN << "client send incomplete header" << std::endl;
+				LOG_WARN << "client send incomplete header" << LOG_ENDL;
 				buffered_on_error(bufev, 0, arg);
 				return;
 			}
@@ -115,10 +115,11 @@
 			evpHeader = (EVPHeader*)headerBuff;
 			
 			// check header
-			if (evpHeader->cmd <= EVPCommand::EVPC__FIRST || evpHeader->cmd >= EVPCommand::EVPC__LAST || 
+			if (evpHeader->proto <= EVPProto::EVPP__FIRST || evpHeader->proto >= EVPProto::EVPP__LAST || 
+				evpHeader->cmd <= EVPCommand::EVPC__FIRST || evpHeader->cmd >= EVPCommand::EVPC__LAST || 
 				evpHeader->size < sizeof(EVPHeader) || evpHeader->size > CLIENT_BUFFER_MAX)
 			{
-				LOG_WARN << "client send invalid header" << std::endl;
+				LOG_WARN << "client send invalid header" << LOG_ENDL;
 				buffered_on_error(bufev, 0, arg);
 				return;
 			}
@@ -169,7 +170,7 @@
 			{
 				size_t writeSize = bufferevent_write(bufev, cs.sendBuff, cs.sendBuffSize);
 				if (writeSize != cs.sendBuffSize)
-					LOG_WARN << "server send truncate " << (cs.sendBuffSize - writeSize) << " bytes" << std::endl;
+					LOG_WARN << "server send truncate " << (cs.sendBuffSize - writeSize) << " bytes" << LOG_ENDL;
 				
 				if (cs.deleteSendBuff)
 					delete[] cs.sendBuff;
@@ -178,7 +179,7 @@
 		
 		if (closeClient)
 		{
-			LOG_DEBUG << "server initiative close" << std::endl;
+			LOG_DEBUG << "server initiative close" << LOG_ENDL;
 			buffered_on_error(bufev, 0, arg);
 		}
 
@@ -190,7 +191,7 @@
 	// check read times
 	if (client->read_times > CLIENT_READ_TIMES_MAX)
 	{
-		LOG_WARN << "client read times to max" << std::endl;
+		LOG_WARN << "client read times to max" << LOG_ENDL;
 		buffered_on_error(bufev, 0, arg);
 	}
 }
@@ -209,19 +210,19 @@
 	int client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
 	if (client_fd < 0)
 	{
-		LOG_WARN << "accept failed" << std::endl;
+		LOG_WARN << "accept failed" << LOG_ENDL;
 		return;
 	}
 
 	// Set the client socket to non-blocking mode.
 	if (setnonblock(client_fd) < 0)
-		LOG_WARN << "failed to set client socket non-blocking" << std::endl;
+		LOG_WARN << "failed to set client socket non-blocking" << LOG_ENDL;
 
 	// We've accepted a new client, create a client object.
 	struct EVClient* client = new EVClient;
 	if (client == NULL)
 	{
-		LOG_ERROR << "malloc failed" << std::endl;
+		LOG_ERROR << "malloc failed" << LOG_ENDL;
 	}
 	client->fd = client_fd;
 	client->proc = evclient_proc;
@@ -232,12 +233,12 @@
 	// We have to enable it before our callbacks will be called.
 	bufferevent_enable(client->buf_ev, EV_READ);
 
-	LOG_INFO << "Accepted connection from " << inet_ntoa(client_addr.sin_addr) << std::endl;
+	LOG_INFO << "Accepted connection from " << inet_ntoa(client_addr.sin_addr) << LOG_ENDL;
 }
 
 int server_main(int argc, char **argv)
 {
-	//initLogger(LV_DEBUG);
+	LOG_NOTICE << "server_main" << LOG_ENDL;
 
 	// Initialize libevent.
 	event_init();
@@ -246,7 +247,7 @@
 	int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
 	if (listen_fd < 0)
 	{
-		LOG_ERROR << "create socket failed" << std::endl;
+		LOG_ERROR << "create socket failed" << LOG_ENDL;
 		return EXIT_FAILURE;
 	}
 	
@@ -255,26 +256,28 @@
 	listen_addr.sin_family = AF_INET;
 	listen_addr.sin_addr.s_addr = INADDR_ANY;
 	listen_addr.sin_port = htons(SERVER_PORT);
+	
+	int reuseaddr_on = REUSEADDR_ON;
+	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on));
+	if (setnonblock(listen_fd) < 0)
+	{
+		LOG_ERROR << "failed to set server socket to non-blocking" << LOG_ENDL;
+		return EXIT_FAILURE;
+	}
+
 	if (bind(listen_fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) < 0)
 	{
-		LOG_ERROR << "bind failed" << std::endl;
+		LOG_ERROR << "bind failed" << LOG_ENDL;
 		return EXIT_FAILURE;
 	}
 	
 	if (listen(listen_fd, 5) < 0)
 	{
-		LOG_ERROR << "listen failed" << std::endl;
+		LOG_ERROR << "listen failed" << LOG_ENDL;
 		return EXIT_FAILURE;
 	}
 	
 	// Set the socket to non-blocking, this is essential in event based programming with libevent.
-	int reuseaddr_on = REUSEADDR_ON;
-	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on));
-	if (setnonblock(listen_fd) < 0)
-	{
-		LOG_ERROR << "failed to set server socket to non-blocking" << std::endl;
-		return EXIT_FAILURE;
-	}
 
 	// We now have a listening socket, we create a read event to be notified when a client connects.
 	struct event ev_accept;
@@ -284,9 +287,17 @@
 	// Start the event loop.
 	event_dispatch();
 
+	close(listen_fd);
+	listen_fd = 0;
 	return EXIT_SUCCESS;
 }
 
+void server_stop()
+{
+	LOG_NOTICE << "server_stop" << LOG_ENDL;
+	event_loopexit(NULL);
+}
+
 void ev_send_status_packet(EVClientStub& client, EVPStatus::EVPS status)
 {
 	client.sendBuffSize = sizeof(EVPHeader)+sizeof(EVP_Status);
diff --git a/FaceServer/ev_server.h b/FaceServer/ev_server.h
index 75749b5..6a47cda 100644
--- a/FaceServer/ev_server.h
+++ b/FaceServer/ev_server.h
@@ -41,6 +41,7 @@
 //#define USER_DEFINE_EVCLIENT_PROC
 
 int server_main(int argc, char **argv);
+void server_stop();
 
 void ev_send_packet(EVClientStub& client);
 void ev_send_status_packet(EVClientStub& client, EVPStatus::EVPS status);
diff --git a/FaceServer/face_daemon_proto.h b/FaceServer/face_daemon_proto.h
new file mode 100644
index 0000000..029beb2
--- /dev/null
+++ b/FaceServer/face_daemon_proto.h
@@ -0,0 +1,48 @@
+#ifndef _FACE_DAEMON_PROTO_H_
+#define _FACE_DAEMON_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include "ev_proto.h"
+
+#include <vector>
+
+#pragma pack(1)
+
+struct FaceDaemonCommand
+{
+	enum FDC
+	{
+		FDC__FIRST,
+		FDC_SENSETIMEFACEDETECT = EVPCommand::EVPC_USER_DEFINE + 1, // 129
+		FDC_SENSETIMEFACEDETECT_RESULT,
+		FDC_SENSETIMEFACEDETECT_PB,
+		FDC_SENSETIMEFACEDETECT_RESULT_JSON,
+		FDC_SENSETIMEFACEDETECT_SAVE,
+		FDC__LAST,
+	};
+};
+
+struct FDP_Image
+{
+	int32_t school_id;
+	int16_t mb_type; // MB_Frame::MBFType
+	int16_t width;
+	int16_t height;
+	uint8_t buff[0];
+};
+
+struct FDP_FaceDetectResult
+{
+	int32_t db_id;
+	int32_t st_id; // sensetime id
+	
+	FDP_FaceDetectResult(int32_t _db_id, int32_t _st_id) : db_id(_db_id), st_id(_st_id)
+	{}
+};
+
+#pragma pack()
+
+typedef std::vector<FDP_FaceDetectResult> fdr_vec_t;
+
+#endif
diff --git a/FaceServer/facelist-3.pb b/FaceServer/facelist-3.pb
new file mode 100644
index 0000000..86e15d0
--- /dev/null
+++ b/FaceServer/facelist-3.pb
Binary files differ
diff --git a/FaceServer/main_face_daemon.cpp b/FaceServer/main_face_daemon.cpp
index 9058ee4..581cbc2 100644
--- a/FaceServer/main_face_daemon.cpp
+++ b/FaceServer/main_face_daemon.cpp
@@ -1,168 +1,99 @@
-#include "PipeLine.h"
-#include "MaterialBuffer.h"
-#include "PL_RTSPClient.h"
-#include "PL_RTSPServer.h"
-#include "PL_H264Decoder.h"
-#include "PL_H264Encoder.h"
-#include "PL_AVFrameYUV420.h"
-#include "PL_AVFrameBGRA.h"
-#include "PL_Queue.h"
-#include "PL_Scale.h"
-#include "PL_Fork.h"
-#include "PL_Payer.h"
-#include "PL_Gainer.h"
-#include "PL_SensetimeFaceTrack.h"
-#include "PL_SensetimeFaceDetect.h"
-#include "PL_DlibFaceTrack.h"
-
-#include "PipeLinePool.h"
+#include <MaterialBuffer.h>
+#include <logger.h>
 
 #include "ev_server.h" 
 #include "ev_proto.h"
 #include "face_daemon_proto.h"
 
-#include "SensetimeFaceAPIWrapper/src/FaceDBPool.h"
-#include "SensetimeFaceAPIWrapper/src/faceAPI.h"
+#include <PbFaceList.pb.h>
 
-#include "logger.h"
+#include <signal.h>
 
-template<typename TPoolPtr, typename TPoolElem>
-struct PoolElemLocker
-{
-	TPoolPtr pool;
-	TPoolElem elem;
-	PoolElemLocker(TPoolPtr _pool, TPoolElem _elem) : pool(_pool), elem(_elem)
-	{
-		
-	}
-	~PoolElemLocker()
-	{
-		pool->release(elem);
-		pool->notify_free();
-	}
-};
+#include <sstream>
+#include <iostream>
 
-template<typename TArrayPtr>
-struct ArrayDeleter
-{
-	TArrayPtr array;
-	ArrayDeleter(TArrayPtr _array) : array(_array)
-	{
-		
-	}
-	~ArrayDeleter()
-	{
-		delete[] array;
-	}
-};
-
-PipeLinePool g_PipeLinePool;
-
-FaceDBPool g_faceAPIPool;//#todo config
+Logger g_logger(std::cout);
 
 evclient_proc_t evclient_proc;
 
-bool send_SensetimeFaceDetectResult(EVClientStub& client, PipeMaterial& lastPm)
+void _sigint(int sign_no)
 {
-	//if (lastPm.type != PipeMaterial::PMT_PM_LIST)
+	server_stop();
+}
 
-	//PipeMaterial& facePM = ((PipeMaterial*)(lastPm.buffer))[1];
-	//st_ff_vect_t& faceFeatures = *((st_ff_vect_t*)facePM.buffer);
-	//LOG_NOTICE << "faceFeatures " << faceFeatures.size() << std::endl;
-	//#todo send result packet
-
-	if (lastPm.buffer == nullptr || lastPm.type != PipeMaterial::PMT_BYTES || lastPm.buffSize != sizeof(SensetimeFaceDetectResult))
+bool send_SensetimeFaceDetectResultJson(EVClientStub& client, const fdr_vec_t& result)
+{
+	std::stringstream ss;
+	ss << "{" << std::endl;
+	ss << "\"ret\":" << 0 << "," << std::endl;
+	ss << "\"count\":" << result.size() << "," << std::endl;
+	ss << "\"result\":[";
+	for(fdr_vec_t::const_iterator iter = result.begin(); iter != result.end(); ++iter)
 	{
-		LOG_WARN << "pm not available" << std::endl;
-		ev_send_status_packet(client, EVPStatus::EVPS_INTERNAL_ERROR);
-		return false;
+		ss << "[" << iter->db_id << "," << iter->st_id << "]";
+		if (iter != std::prev(result.end()))
+			ss << ",";
 	}
-	
-	const SensetimeFaceDetectResult*  result = (const SensetimeFaceDetectResult*)lastPm.buffer;
-	
-	client.sendBuffSize = sizeof(EVPHeader)+sizeof(SensetimeFaceDetectResult);
+	ss << "]" << std::endl;
+	ss << "}";
+
+	std::string output(ss.str());//#todo avoid copy
+	client.sendBuffSize = output.size() + 1;
 	client.sendBuff = new uint8_t[client.sendBuffSize];
+	strcpy((char*)client.sendBuff, output.c_str());
 	client.deleteSendBuff = true;
 	
-	EVPHeader* evpHeader = new (client.sendBuff) EVPHeader;
-	evpHeader->cmd = FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_RESULT;
-	evpHeader->size = client.sendBuffSize;
-	
-	SensetimeFaceDetectResult* evpSub = new (client.sendBuff + sizeof(EVPHeader)) SensetimeFaceDetectResult;
-	evpSub->school_id = result->school_id;
-	evpSub->st_id = result->st_id;
-	
+	LOG_DEBUG << (char*)client.sendBuff << LOG_ENDL;
+
 	return true;
 }
 
-bool ev_proc_SensetimeFaceDetect(EVClientStub& client)
+bool ev_proc_SensetimeFaceDetectPB(EVClientStub& client)
 {
-	//#test send 01000B0000004142434445
+	//#test send //00038300FE4B0000+pb
+	//EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
 	//LOG_DEBUG << "cmd=" << evpHeader->cmd << ", size=" << evpHeader->size << ", \t" << (char*)(evpHeader + sizeof(EVPHeader)) << std::endl;
 	//return true;
 	
-	FDP_Image* fdpImage = (FDP_Image*)(client.recvBuff + sizeof(EVPHeader));
-
-	FaceDB* _faceDB = g_faceAPIPool.get_free(fdpImage->school_id);
-	if (_faceDB == nullptr)
-	{
-		LOG_WARN << "can't get face db" << std::endl;
-		ev_send_status_packet(client, EVPStatus::EVPS_PARAMETER_ERROR);
-		return false;
-	}
+	EVPHeader* evpHeader = (EVPHeader*)client.recvBuff;
 	
-	PoolElemLocker<FaceDBPool*, int> _lock_faceAPI(&g_faceAPIPool, fdpImage->school_id);
+	PbFaceList pbFaceList;
+	pbFaceList.ParseFromArray(client.recvBuff + sizeof(EVPHeader), evpHeader->size - sizeof(EVPHeader));
+	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());
 
-	PipeLine* pipeLine = g_PipeLinePool.get_free();
-	if (pipeLine == nullptr)
+	for(int i = 0; i < pbFaceList.image_count(); i++)
 	{
-		LOG_WARN << "can't get free pipeline" << std::endl;
-		ev_send_status_packet(client, EVPStatus::EVPS_INTERNAL_ERROR);
-		return false;
-	}
-	
-	PoolElemLocker<PipeLinePool*, PipeLine*> _lock_pipeLine(&g_PipeLinePool, pipeLine);
+		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());
+			
+		char imgfn[100 * 1024];
+		sprintf(imgfn, "PB_%d_%d.yuv", 0, i);
 
-	// fill
-	SensetimeFaceDetectDbFrame dbFrame;
-	dbFrame.type = (MB_Frame::MBFType)(fdpImage->mb_type);
-	dbFrame.buffSize = client.recvBuffSize - sizeof(EVPHeader) - sizeof(FDP_Image);
-	dbFrame.buffer = new uint8_t[dbFrame.buffSize];
-	ArrayDeleter<uint8_t*> _del_img((uint8_t*)dbFrame.buffer);
-	memcpy(dbFrame.buffer, fdpImage->buff, dbFrame.buffSize);
-	dbFrame.width = fdpImage->width;
-	dbFrame.height = fdpImage->height;
-	dbFrame.school_id = fdpImage->school_id;
-	dbFrame._faceDB = _faceDB;
-
-	PipeMaterial pm;
-	pm.type = PipeMaterial::PMT_FRAME;
-	pm.buffer = &dbFrame;
-	pm.buffSize = 0;
-
-	PipeLineElem* plElem = pipeLine->pipe(&pm);
-	if (! pipeLine->check_pipe_complete(plElem))
-	{
-		LOG_WARN << "pipeline not complete" << std::endl;
-		ev_send_status_packet(client, EVPStatus::EVPS_INTERNAL_ERROR);
-		return false;
+		FILE * pFile = fopen(imgfn, "wb");
+		fwrite(*(pbFaceListImage.img().data()), sizeof(char), pbFaceListImage.size(), pFile);
+		fclose(pFile);
+		pFile = nullptr;
 	}
+		
+		
+	fdr_vec_t result;
 	
-	if (!plElem->gain(pm))
-	{
-		LOG_WARN << "pipeline gain error" << std::endl;
-		ev_send_status_packet(client, EVPStatus::EVPS_INTERNAL_ERROR);
-		return false;
-	}
+	//do detect(client)
+	result.push_back(FDP_FaceDetectResult(-1,123));
+	result.push_back(FDP_FaceDetectResult(2,456));
+	result.push_back(FDP_FaceDetectResult(0,0));
 	
-	// can not release pipleline unless pm not used
-	send_SensetimeFaceDetectResult(client, pm);
+	send_SensetimeFaceDetectResultJson(client, result);
 
 	return false;
 }
 
-bool ev_proc(EVClientStub& client)
+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)
 	{
@@ -172,12 +103,40 @@
 
 	switch(evpHeader->cmd)
 	{
-	case EVPCommand::EVPC_USER_DEFINE + 1:
-		return ev_proc_SensetimeFaceDetect(client);
+	case FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_PB:
+		//000383000800000001
+		return ev_proc_SensetimeFaceDetectPB(client);
 	break;
 	default:
 		LOG_WARN << "Unknown command" << std::endl;
-		ev_send_status_packet(client, EVPStatus::EVPS_PARAMETER_ERROR);
+		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" << std::endl;
+		return false;
+	}
+
+	switch(evpHeader->proto)
+	{
+	case EVPProto::EVPP_PROTOBUF:
+		return ev_dispatcher_proto_pb(client);
+	break;
+	default:
+		LOG_WARN << "Unknown proto" << std::endl;
+		ev_send_status_packet(client, EVPStatus::EVPS_PROTO_ERROR);
 		return false;
 	break;
 	}
@@ -188,46 +147,10 @@
 
 int main(int argc, char** argv)
 {
-	initLogger(LV_DEBUG);
+	g_logger.set_level(VERBOSE);
 	
-	PipeLine::register_global_elem_creator("PL_SensetimeFaceTrack", create_PL_SensetimeFaceTrack);
-	PipeLine::register_global_elem_creator("PL_Gainer", create_PL_Gainer);
-	
-	g_PipeLinePool = new PipeLinePool(true);
-	
-	for (int i = 0; i < 5; i++)
-	{
-		PipeLine* pipeLine = new PipeLine;
+	signal(SIGINT, _sigint);
 
-		{
-			PL_Payer_Config config;
-			config.copyData = true;//#todo false
-			PL_Gainer* ple = (PL_Gainer*)pipeLine->push_elem("PL_Gainer");
-			bool ret = ple->init(&config);
-			if (!ret)
-			{
-				LOG_ERROR << "ple init error" << std::endl;
-				exit(EXIT_FAILURE);
-			}
-		}
-		
-		{
-			SensetimeFaceTrackConfig config;
-			config.draw_face_rect = false;
-			config.draw_face_feature_point = false;
-			config.generate_face_feature = true;
-			PL_SensetimeFaceTrack* ple = (PL_SensetimeFaceTrack*)pipeLine->push_elem("PL_SensetimeFaceTrack");
-			bool ret = ple->init(&config);
-			if (!ret)
-			{
-				LOG_ERROR << "ple init error" << std::endl;
-				exit(EXIT_FAILURE);
-			}
-		}
-		
-		g_PipeLinePool.manage(pipeLine);
-	}
-	
-	evclient_proc = ev_proc;
+	evclient_proc = ev_dispatcher_proto;
 	return server_main(argc, argv);
 }
diff --git a/FaceServer/make.sh b/FaceServer/make.sh
new file mode 100644
index 0000000..e15e9e6
--- /dev/null
+++ b/FaceServer/make.sh
@@ -0,0 +1,38 @@
+#!/bin/sh
+
+PIPELINE_BASE=/opt/RtspFace
+
+VISITFACE_BASE=/opt/VisitFace/RtspNativeCodec/app/src/main/cpp
+
+PROTOBUF_BASE=/opt/protobuf/inst
+PROTOBUF_INC="-I$PROTOBUF_BASE/include"
+PROTOBUF_LIB="-L$PROTOBUF_BASE/lib -lprotobuf"
+
+CPPFLAGS+="-g -c -std=c++11 -pthread -I$PIPELINE_BASE -I$VISITFACE_BASE $PROTOBUF_INC "
+LDFLAGS+="-pthread -levent $PROTOBUF_LIB "
+
+rm *.o
+rm face_server
+rm test_client
+
+g++ $PIPELINE_BASE/Logger/src/logger.cc $CFLAGS $CPPFLAGS
+g++ ev_server.cpp -DUSER_DEFINE_EVCLIENT_PROC $CFLAGS $CPPFLAGS
+g++ main_face_daemon.cpp $CFLAGS $CPPFLAGS
+g++ $VISITFACE_BASE/PbFaceList.pb.cc $CFLAGS $CPPFLAGS
+
+g++ test_client.cpp $CFLAGS $CPPFLAGS
+
+g++ -g -std=c++11 \
+  logger.o \
+  ev_server.o \
+  PbFaceList.pb.o \
+  main_face_daemon.o \
+  $LDFLAGS -o face_server
+#
+
+g++ -g -std=c++11 \
+  test_client.o \
+  $LDFLAGS -o test_client
+#
+
+#export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/protobuf/inst/lib
diff --git a/FaceServer/test_client.cpp b/FaceServer/test_client.cpp
new file mode 100644
index 0000000..5383601
--- /dev/null
+++ b/FaceServer/test_client.cpp
@@ -0,0 +1,97 @@
+/************************************
+ * For msmr 
+ * server.c
+ * tesing the speed of bufferevent_write
+ * 2015-02-03
+ * author@tom
+************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <event2/event.h>
+#include <event2/bufferevent.h>
+#include <event2/buffer.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+
+#include <unistd.h>
+
+#include "ev_proto.h"
+#include "face_daemon_proto.h"
+
+void make_msg(char* mesg, int length)
+{
+	EVPHeader* evpHeader = new (mesg) EVPHeader;
+	evpHeader->proto = EVPProto::EVPP_PROTOBUF;
+	evpHeader->cmd = FaceDaemonCommand::FDC_SENSETIMEFACEDETECT_PB;
+	evpHeader->size = length;
+	
+	FILE* pFile = fopen("facelist-3.pb", "rb");
+	size_t fsize = fread(mesg + sizeof(EVPHeader), 1, length - sizeof(EVPHeader), pFile);
+	fclose(pFile);
+}
+
+int main()
+{
+    // build the message to be sent
+    int length = 19454; // the size of message
+    char* mesg = (char*)malloc((length+1)*sizeof(char)); // Look out the end mark '/0' of a C string
+    if (mesg == NULL)
+        exit(1);
+    int i;
+    //for (i=0; i<length; i++) 
+    //    strcat(mesg, "a");
+
+	make_msg(mesg, length);
+
+    printf("%s\n", mesg);
+    printf("%d\n", (int)strlen(mesg));
+
+    // build socket
+    int port = 5432;
+
+    struct sockaddr_in server_addr;
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_addr.s_addr = inet_addr("192.168.1.146");
+    server_addr.sin_port = htons(port);
+
+    // build event base
+    struct event_base* base = event_base_new();
+
+    // set TCP_NODELAY to let data arrive at the server side quickly
+    evutil_socket_t fd;
+    fd = socket(AF_INET, SOCK_STREAM, 0);
+    struct bufferevent* conn = bufferevent_socket_new(base,fd,BEV_OPT_CLOSE_ON_FREE);
+    int enable = 1;
+    if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void*)&enable, sizeof(enable)) < 0)
+       printf("ERROR: TCP_NODELAY SETTING ERROR!\n");
+    //bufferevent_setcb(conn, NULL, NULL, NULL, NULL); // For client, we don't need callback function
+    bufferevent_enable(conn, EV_WRITE);
+    if(bufferevent_socket_connect(conn,(struct sockaddr*)&server_addr,sizeof(server_addr)) == 0)
+            printf("connect success\n");
+
+    // start to send data
+    bufferevent_write(conn,mesg,length);
+    // check the output evbuffer
+    struct evbuffer* output = bufferevent_get_output(conn);
+    int len = 0;
+    len = evbuffer_get_length(output);
+    printf("output buffer has %d bytes left\n", len);
+
+    event_base_dispatch(base);
+ 
+	//char readbuf[100*1024];
+	//int readbufsize = read(fd, readbuf, sizeof(readbuf));
+	//printf("read:\n%s\n", readbuf);
+ 
+    free(mesg);
+    mesg = NULL;
+
+    bufferevent_free(conn);
+    event_base_free(base);
+
+    printf("Client program is over\n");
+
+    return 0;
+}
\ No newline at end of file

--
Gitblit v1.8.0