development-history/proxy.git

			@@ -2,25 +2,19 @@
			#include "MaterialBuffer.h"
			#include "logger.h"

			//#include "SensetimeFaceAPIWrapper/src/FaceDBPool.h"
			//#include "SensetimeFaceAPIWrapper/src/faceAPI.h"
			#include <opencv2/opencv.hpp>
			#include <cv_face.h>

			struct PL_SensetimeFaceDetect_Internal
			{
			//uint8_t buffer[192010804];
			//size_t buffSize;
			//size_t buffSizeMax;
			MB_Frame lastFrame;
			SensetimeFaceDetectConfig config;

			bool payError;

			cv_handle_t handle_track;
			PL_SensetimeFaceDetectConfig config;
			SensetimeFaceDetectResult lastResult;

			PL_SensetimeFaceDetect_Internal() :
			//buffSize(0), buffSizeMax(sizeof(buffer)),
			lastFrame(), config(), payError(true),
			handle_track(nullptr)
			payError(true), config(), lastResult()
			{
			}

			@@ -30,15 +24,13 @@

			void reset()
			{
			//buffSize = 0;
			payError = true;

			MB_Frame _lastFrame;
			lastFrame = _lastFrame;
			SensetimeFaceDetectConfig _config;
			PL_SensetimeFaceDetectConfig _config;
			config = _config;

			handle_track = nullptr;
			SensetimeFaceDetectResult _lastResult;
			lastResult = _lastResult;
			}
			};

			@@ -62,156 +54,71 @@
			PL_SensetimeFaceDetect_Internal* in = (PL_SensetimeFaceDetect_Internal*)internal;
			in->reset();

			SensetimeFaceDetectConfig* config = (SensetimeFaceDetectConfig*)args;
			in->config = *config;
			if (in->config.point_size == 21)
			in->config.point_size_config = CV_DETECT_ENABLE_ALIGN_21;
			else if (in->config.point_size == 106)
			in->config.point_size_config = CV_DETECT_ENABLE_ALIGN_106;
			else
			if (args != nullptr)
			{
			LOG_ERROR << "alignment point size must be 21 or 106";
			return false;
			PL_SensetimeFaceDetectConfig* config = (PL_SensetimeFaceDetectConfig*)args;
			in->config = *config;
			}

			// init handle
			cv_result_t cv_result = cv_face_create_tracker(&(in->handle_track), nullptr,
			in->config.point_size_config \| CV_FACE_TRACKING_TWO_THREAD);
			if (cv_result != CV_OK)
			{
			LOG_ERROR << "cv_face_create_tracker failed, error code" << cv_result;
			return false;
			}

			int val = 0;
			cv_result = cv_face_track_set_detect_face_cnt_limit(in->handle_track, in->config.detect_face_cnt_limit, &val);
			if (cv_result != CV_OK)
			{
			LOG_ERROR << "cv_face_track_set_detect_face_cnt_limit failed, error : " << cv_result;
			return false;
			}
			else
			LOG_ERROR << "detect face count limit : " << val;

			return true;
			}

			void PL_SensetimeFaceDetect::finit()
			{
			PL_SensetimeFaceDetect_Internal* in = (PL_SensetimeFaceDetect_Internal*)internal;

			// destroy track handle
			cv_face_destroy_tracker(in->handle_track);
			in->handle_track = nullptr;
			}

			int doFaceDetect(PL_SensetimeFaceDetect_Internal* in,
			uint8_t* buffer, size_t width, size_t height, size_t stride, cv_pixel_format cvPixFmt)
			{
			//resize(bgr_frame, bgr_frame, Size(frame_width, frame_height), 0, 0, INTER_LINEAR);

			int face_count = 0;
			cv_result_t cv_result = CV_OK;
			cv_face_t* p_face = nullptr;

			// realtime track
			cv_result = cv_face_track(in->handle_track, buffer, cvPixFmt,
			width, height, stride,
			CV_FACE_UP, &p_face, &face_count);
			if (cv_result != CV_OK)
			{
			LOG_ERROR << "cv_face_track failed, error : " << cv_result;
			cv_face_release_tracker_result(p_face, face_count);
			return -1;
			}

			// draw the video
			cv::Mat yuvMat(cv::Size(1920,1080), CV_8UC3, buffer);//#todo
			cv::Mat yMat(cv::Size(1920,1080), CV_8UC1, buffer);
			for (int i = 0; i < face_count; i++)
			{
			LOGP(DEBUG, "face: %d-----[%d, %d, %d, %d]-----id: %d", i,
			p_face[i].rect.left, p_face[i].rect.top,
			p_face[i].rect.right, p_face[i].rect.bottom, p_face[i].ID);

			LOGP(DEBUG, "face pose: [yaw: %.2f, pitch: %.2f, roll: %.2f, eye distance: %.2f]",
			p_face[i].yaw,
			p_face[i].pitch, p_face[i].roll, p_face[i].eye_dist);

			cv::Scalar scalar_color = CV_RGB(p_face[i].ID * 53 % 256,
			p_face[i].ID * 93 % 256,
			p_face[i].ID * 143 % 256);

			//cv::rectangle(yMat, cv::Point2f(0, 0), cv::Point2f(50, 50), scalar_color, 2);
			//cv::rectangle(yMat, cv::Point2f(500, 500), cv::Point2f(550, 550), scalar_color, 2);

			cv::rectangle(yMat, cv::Point2f(static_cast<float>(p_face[i].rect.left),
			static_cast<float>(p_face[i].rect.top)),
			cv::Point2f(static_cast<float>(p_face[i].rect.right),
			static_cast<float>(p_face[i].rect.bottom)), scalar_color, 2);

			for (int j = 0; j < p_face[i].points_count; j++)
			{
			cv::circle(yMat, cv::Point2f(p_face[i].points_array[j].x,
			p_face[i].points_array[j].y), 1, cv::Scalar(255, 255, 255));
			}
			}

			//if (face_count > 0)
			//{
			// static size_t f=0;
			// char fname[50];
			// sprintf(fname, "face-%u.yuv420", ++f);
			// FILE * pFile = fopen (fname,"wb");
			// fwrite (yuvMat.data , sizeof(char), 192010801.5, pFile);
			// printf("write face file %s\n", fname);
			// fclose(pFile);
			//}

			// release the memory of face
			cv_face_release_tracker_result(p_face, face_count);

			return face_count;
			}

			bool PL_SensetimeFaceDetect::pay(const PipeMaterial& pm)
			{
			PL_SensetimeFaceDetect_Internal* in = (PL_SensetimeFaceDetect_Internal*)internal;

			if (pm.type != PipeMaterial::PMT_FRAME)

			in->payError = true;
			{
			LOG_ERROR << "PL_H264Encoder::pay only support PMT_FRAME";
			SensetimeFaceDetectResult _lastResult;
			in->lastResult = _lastResult;
			}

			if (pm.type != PipeMaterial::PMT_FRAME \|\| !(in->config.payWithDbFrame))
			{
			LOG_ERROR << "Only support PMT_FRAME (SensetimeFaceDetectDbFrame)" << std::endl;
			return false;
			}

			if (pm.buffer == nullptr)
			return false;

			MB_Frame* frame = (MB_Frame*)pm.buffer;
			SensetimeFaceDetectDbFrame* frame = (SensetimeFaceDetectDbFrame*)pm.buffer;
			if (frame->type != MB_Frame::MBFT_YUV420)
			{
			LOG_ERROR << "PL_H264Encoder::pay only support MBFT_YUV420";
			LOG_ERROR << "Only support MBFT_YUV420" << std::endl;
			return false;
			}

			int face_count = doFaceDetect(in, (uint8_t*)frame->buffer, 1920, 1080, 1920, CV_PIX_FMT_YUV420P);//#todo
			if (face_count < 0)
			{
			in->payError = true;
			return false;
			}
			else
			in->payError = false;
			//FaceDB* _faceDB = (FaceDB*)frame->_faceDB;
			//if (_faceDB == nullptr)
			//{
			// LOG_ERROR << "FaceDB is null" << std::endl;
			// return false;
			//}

			//in->buffer readly

			in->lastFrame.type = MB_Frame::MBFT_YUV420;
			in->lastFrame.buffer = frame->buffer;//#todo should copy
			in->lastFrame.buffSize = frame->buffSize;
			in->lastFrame.width = frame->width;
			in->lastFrame.height = frame->height;
			in->lastFrame.pts = frame->pts;

			const size_t expectedYUVSize = frame->width * frame->height * 1.5;
			if (frame->buffSize < expectedYUVSize)
			{
			LOG_WARN << "image size not ok" << std::endl;
			return false;
			}

			cv::Mat yuvMat(cv::Size(frame->width,frame->height), CV_8UC3, frame->buffer);
			//cv_feature_t* feature = _faceDB->extract_feature(yuvMat);
			//in->lastResult.st_id = _faceDB->search_db(feature);

			//in->lastResult.st_id = _faceDB->do_reasch(yuvMat);
			//#todo release feature

			in->lastResult.school_id = frame->school_id;

			in->payError = false;
			return true;
			}

			@@ -219,13 +126,22 @@
			{
			PL_SensetimeFaceDetect_Internal* in = (PL_SensetimeFaceDetect_Internal*)internal;

			if (!in->payError)
			{
			pm.type = PipeMaterial::PMT_FRAME;
			pm.buffer = &(in->lastFrame);
			pm.buffSize = 0;
			pm.former = this;
			}
			pm.former = this;
			return !in->payError;

			if (in->payError)
			{
			return false;
			}

			if (! in->config.resultStructOnly)
			{
			LOG_ERROR << "Only support resultStructOnly" << std::endl;
			return false;
			}

			pm.type = PipeMaterial::PMT_BYTES;
			pm.buffer = &(in->lastResult);
			pm.buffSize = sizeof(SensetimeFaceDetectResult);

			return true;
			}