cleaan up

houxiao

2017-08-01 ab5f950eb26752a7a26ea746dd22a41a00b1074a

 RtspFace/PL_SensetimeFaceTrackMultiTrd.cpp

@@ -4,14 +4,37 @@
#include "MediaHelper.h"



#ifdef USE_OPENCV



#include <opencv2/opencv.hpp>



#endif



#include <cv_face.h>



class SensetimeFaceTrackThread {

class SensetimeFaceTrackThread

{

private:

   pthread_t track_thid;

   pthread_mutex_t thd_mutex;

   pthread_mutex_t res_mutex;

   mutable volatile bool thread_running;

   mutable volatile bool buffer_updated;

   mutable volatile bool res_updated;

   mutable volatile bool is_busy;



   unsigned char *image;

   cv_pixel_format pixel_format;

   int image_width;

   int image_height;

   int image_stride;

   int buffer_size;

   cv_face_orientation orientation;

   cv_face_t *p_faces;

   int faces_count;

   cv_result_t track_result;

   SensetimeFaceTrackConfig config;



   st_ff_vect_t faceFeatures;

   cv_handle_t tracker_handle;



public:

    SensetimeFaceTrackThread():

                                image_width(0), image_height(0),

@@ -22,7 +45,8 @@
    {

    }



    ~SensetimeFaceTrackThread() {

   ~SensetimeFaceTrackThread()

   {

        thread_running = false;

        pthread_mutex_unlock(&thd_mutex);

        pthread_join(track_thid, nullptr);

@@ -35,42 +59,52 @@
        image = nullptr;

    }



    int initial(){

   int initial()

   {

        int ret = pthread_create(&track_thid, NULL, track_thread, this);

        if (ret != 0) {

      if (ret != 0)

      {

            LOGP(ERROR, "pthread_create: %s/n", strerror(ret));

            thread_running = false;

            return ret;

        } else {

      }

      else

      {

            thread_running = true;

        }



        ret = pthread_mutex_init(&thd_mutex, nullptr);

        if (ret != 0) {

      if (ret != 0)

      {

            LOGP(ERROR, "pthread_mutex_init thd_mutex: %s/n", strerror(ret));

            thread_running = false;

            return ret;

        }



        ret = pthread_mutex_init(&res_mutex, nullptr);

        if (ret != 0) {

      if (ret != 0)

      {

            LOGP(ERROR, "pthread_mutex_init res_mutex: %s/n", strerror(ret));

            thread_running = false;

            return ret;

        }



        ret = cv_face_create_tracker(&tracker_handle, nullptr, config.point_size_config);

        if (ret != 0) {

      if (ret != 0)

      {

            LOGP(ERROR, "cv_face_create_tracker: %s/n", strerror(ret));

            thread_running = false;

            return ret;

        }



        ret = cv_face_track_set_detect_face_cnt_limit(tracker_handle, config.detect_face_cnt_limit, nullptr);

        if (ret != 0) {

      if (ret != 0)

      {

            LOGP(ERROR, "cv_face_track_set_detect_face_cnt_limit: %s/n", strerror(ret));

            thread_running = false;

            return ret;

        }



        return ret;

    }



@@ -80,9 +114,10 @@
            int image_width,

            int image_height,

            int image_stride,

            cv_face_orientation orientation = CV_FACE_UP

    ) {

        if(is_busy)return;

         cv_face_orientation orientation = CV_FACE_UP)

   {

      if (is_busy)

         return;

        copy_image(image, image_height, image_stride);

        this->pixel_format = pixel_format;

        this->image_width = image_width;

@@ -91,26 +126,32 @@
        this->orientation = orientation;

        buffer_updated =true;

        int ret = pthread_mutex_unlock(&thd_mutex);

        if (ret != 0) {

      if (ret != 0)

      {

            LOGP(ERROR, "pthread_mutex_unlock: %s/n", strerror(ret));

            thread_running = false;

        }

    }



    int initial_license(char *path) {

   int initial_license(char *path)

   {

        int res = 0;

        FILE *licFile = fopen(path, "rb");

        if (licFile != nullptr) {

      if (licFile != nullptr)

      {

            char licBuffer[1025 * 5] = {'\0'};

            size_t licSize = fread(licBuffer, sizeof(uint8_t), sizeof(licBuffer), licFile);

            fclose(licFile);



            if (licSize > 0) {

         if (licSize > 0)

         {

                res = cv_face_init_license_config(licBuffer);

                LOG_INFO << "cv_face_init_license_config 1 ret=" << res << LOG_ENDL;

                return res;

            }

        } else {

      }

      else

      {

            LOG_WARN << "cv_face_init_license_config 2 errno=" << errno << LOG_ENDL;

            res = errno;

            return res;

@@ -118,30 +159,46 @@
        return res;

    }



    void set_config(SensetimeFaceTrackConfig& cfg){

   void set_config(SensetimeFaceTrackConfig &cfg)

   {

        config = cfg;

    }



    const SensetimeFaceTrackConfig* get_config(){

   const SensetimeFaceTrackConfig *get_config()

   {

        return &config;

    }



   void get_face_features(st_ff_vect_t &res_vector)

   {

      if (!res_updated) return;

      int ret = pthread_mutex_lock(&res_mutex);

      if (ret != 0)

      {

         LOGP(ERROR, "pthread_mutex_lock res_mutex: %s/n", strerror(ret));

         thread_running = false;

      }

      res_vector = faceFeatures;

      ret = pthread_mutex_unlock(&res_mutex);

      res_updated = false;

      if (ret != 0)

      {

         LOGP(ERROR, "pthread_mutex_unlock res_mutex: %s/n", strerror(ret));

         thread_running = false;

      }

   }



private:

    pthread_t track_thid;

    pthread_mutex_t thd_mutex;

    pthread_mutex_t res_mutex;

    mutable volatile bool thread_running;

    mutable volatile bool buffer_updated;

    mutable volatile bool res_updated;

    mutable volatile bool is_busy;

private:

    static void *track_thread(void *Args) {

   static void *track_thread(void *Args)

   {

        SensetimeFaceTrackThread* tracker = (SensetimeFaceTrackThread*)Args;

        while(tracker->thread_running)

        {

            tracker->is_busy = false;

            int ret = pthread_mutex_lock(&tracker->thd_mutex);

            tracker->is_busy = true;

            if (ret != 0) {

         if (ret != 0)

         {

                LOGP(ERROR, "pthread_mutex_lock: %s/n", strerror(ret));

                tracker->thread_running = false;

                break;

@@ -154,22 +211,24 @@
                                                  tracker->orientation, &tracker->p_faces,

                                                  &tracker->faces_count);





            if (ret != 0) {

         if (ret != 0)

         {

                LOGP(ERROR, "cv_face_track: %s/n", strerror(ret));

                tracker->thread_running = false;

                break;

            }



            ret = pthread_mutex_lock(&tracker->res_mutex);

            if (ret != 0) {

         if (ret != 0)

         {

                LOGP(ERROR, "pthread_mutex_lock res_mutex: %s/n", strerror(ret));

                tracker->thread_running = false;

                break;

            }

            tracker->extract_features();

            ret = pthread_mutex_unlock(&tracker->res_mutex);

            if (ret != 0) {

         if (ret != 0)

         {

                LOGP(ERROR, "pthread_mutex_unlock res_mutex: %s/n", strerror(ret));

                tracker->thread_running = false;

                break;

@@ -180,10 +239,13 @@
        }

    }



    void copy_image(const unsigned char *src, int height, int stride){

   void copy_image(const unsigned char *src, int height, int stride)

   {

        int size = height * stride * 1.5;

        if(image_size() < size){

            if(image != nullptr){

      if (image_size() < size)

      {

         if (image != nullptr)

         {

                delete(image);

            }

            image = new unsigned char[size];

@@ -191,16 +253,19 @@
        }

        memcpy(image, src, size);

    }

    int image_size(){



   int image_size()

   {

        return buffer_size;

    }

private:

    st_ff_vect_t faceFeatures;

    cv_handle_t tracker_handle;

    void extract_features(){



   void extract_features()

   {

        faceFeatures.clear();

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

            if (MH_F_LT(p_faces[i].score, config.score_min)) {

      for (int i = 0; i < faces_count; i++)

      {

         if (MH_F_LT(p_faces[i].score, config.score_min))

         {

                continue;

            }

            SensetimeFaceFeature faceFeature;

@@ -221,20 +286,24 @@


            LOGP(DEBUG, "face pose: [yaw: %.2f, pitch: %.2f, roll: %.2f, eye distance: %.2f]",

                 p_faces[i].yaw, p_faces[i].pitch, p_faces[i].roll, p_faces[i].eye_dist);

            for (int j = 0; j < p_faces[i].points_count; j++) {

         for (int j = 0; j < p_faces[i].points_count; j++)

         {

                PLGH_Point featurePoint;

                featurePoint.X = p_faces[i].points_array[j].x;

                featurePoint.Y = p_faces[i].points_array[j].y;

                faceFeature.featurePoints.points.push_back(featurePoint);

            }

            if (config.generate_face_point) {

         if (config.generate_face_point)

         {

                if (faceFeature.rect.leftTop.X < 0 ||

                    faceFeature.rect.rightBottom.X > image_height ||

                    faceFeature.rect.leftTop.Y < 0 || faceFeature.rect.rightBottom.Y > image_width)

                    faceFeature.outOfFrame = true;

            }

            if (config.generate_face_feature) {

                if (config.evenWidthHeight) {

         if (config.generate_face_feature)

         {

            if (config.evenWidthHeight)

            {

                    if (faceFeature.rect.leftTop.X % 2 != 0) faceFeature.rect.leftTop.X--;

                    if (faceFeature.rect.leftTop.Y % 2 != 0) faceFeature.rect.leftTop.Y--;

                    if (faceFeature.rect.rightBottom.X % 2 != 0) faceFeature.rect.rightBottom.X--;

@@ -242,7 +311,8 @@
                }



                // explode the range

                if (config.explode_feature_rect_x != 0) {

            if (config.explode_feature_rect_x != 0)

            {

                    faceFeature.rect.leftTop.X = clamp(

                            faceFeature.rect.leftTop.X - config.explode_feature_rect_x, 0,

                            faceFeature.rect.leftTop.X);

@@ -251,7 +321,8 @@
                            faceFeature.rect.rightBottom.X, int(image_width - 1));

                }



                if (config.explode_feature_rect_y != 0) {

            if (config.explode_feature_rect_y != 0)

            {

                    faceFeature.rect.leftTop.Y = clamp(

                            faceFeature.rect.leftTop.Y - config.explode_feature_rect_y, 0,

                            faceFeature.rect.leftTop.Y);

@@ -265,38 +336,11 @@
        }

        res_updated = true;

    }

public:

    void get_face_features(st_ff_vect_t& res_vector){

        if(!res_updated) return;

        int ret = pthread_mutex_lock(&res_mutex);

        if (ret != 0) {

            LOGP(ERROR, "pthread_mutex_lock res_mutex: %s/n", strerror(ret));

            thread_running = false;

        }

        res_vector = faceFeatures;

        ret = pthread_mutex_unlock(&res_mutex);

        res_updated = false;

        if (ret != 0) {

            LOGP(ERROR, "pthread_mutex_unlock res_mutex: %s/n", strerror(ret));

            thread_running = false;

        }

    }

private:

    unsigned char *image;

    cv_pixel_format pixel_format;

    int image_width;

    int image_height;

    int image_stride;

    int buffer_size;

    cv_face_orientation orientation;

    cv_face_t *p_faces;

    int faces_count;

    cv_result_t track_result;

    SensetimeFaceTrackConfig config;



};



struct PL_SensetimeFaceTrackMultiTrd_Internal {

struct PL_SensetimeFaceTrackMultiTrd_Internal

{

    //uint8_t buffer[1920*1080*4];

    //size_t buffSize;

    //size_t buffSizeMax;

@@ -310,13 +354,16 @@


    PL_SensetimeFaceTrackMultiTrd_Internal() :

    //buffSize(0), buffSizeMax(sizeof(buffer)),

            lastFrame(), pmList(), frameCount(0) {

         lastFrame(), pmList(), frameCount(0)

   {

    }



    ~PL_SensetimeFaceTrackMultiTrd_Internal() {

   ~PL_SensetimeFaceTrackMultiTrd_Internal()

   {

    }



    void reset() {

   void reset()

   {

        //buffSize = 0;

        payError = true;



@@ -330,22 +377,24 @@
    }

};



PipeLineElem *create_PL_SensetimeFaceTrackMultiTrd() {

PipeLineElem *create_PL_SensetimeFaceTrackMultiTrd()

{

    return new PL_SensetimeFaceTrackMultiTrd;

}



PL_SensetimeFaceTrackMultiTrd::PL_SensetimeFaceTrackMultiTrd() : internal(

        new PL_SensetimeFaceTrackMultiTrd_Internal){

      new PL_SensetimeFaceTrackMultiTrd_Internal)

{

}



PL_SensetimeFaceTrackMultiTrd::~PL_SensetimeFaceTrackMultiTrd() {

PL_SensetimeFaceTrackMultiTrd::~PL_SensetimeFaceTrackMultiTrd()

{

    delete (PL_SensetimeFaceTrackMultiTrd_Internal *) internal;

    internal = nullptr;

    pthread_mutex_destroy(&pay_mutex);;

    pthread_mutex_destroy(&gain_mutex);

}



bool PL_SensetimeFaceTrackMultiTrd::init(void *args) {

bool PL_SensetimeFaceTrackMultiTrd::init(void *args)

{

    PL_SensetimeFaceTrackMultiTrd_Internal *in = (PL_SensetimeFaceTrackMultiTrd_Internal *) internal;

    in->reset();

    SensetimeFaceTrackConfig *config = (SensetimeFaceTrackConfig *) args;

@@ -353,7 +402,8 @@
        config->point_size_config = CV_DETECT_ENABLE_ALIGN_21;

    else if (config->point_size == 106)

        config->point_size_config = CV_DETECT_ENABLE_ALIGN_106;

    else {

   else

   {

        LOG_ERROR << "alignment point size must be 21 or 106" << LOG_ENDL;

        return false;

    }

@@ -365,24 +415,27 @@
    return true;

}



void PL_SensetimeFaceTrackMultiTrd::finit() {

void PL_SensetimeFaceTrackMultiTrd::finit()

{

    PL_SensetimeFaceTrackMultiTrd_Internal *in = (PL_SensetimeFaceTrackMultiTrd_Internal *) internal;



}



int doFaceTrack(PL_SensetimeFaceTrackMultiTrd_Internal *in,

                uint8_t *buffer, size_t width, size_t height, size_t stride,

                cv_pixel_format cvPixFmt) {

            cv_pixel_format cvPixFmt)

{

    PipeLineElemTimingDebugger td(nullptr);

    in->trackThread.do_face_track(buffer, cvPixFmt, width, height, stride);

    return 0;

}



/*static*/ bool

PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV(const PipeMaterial *pm, void *args) {

/*static*/ bool PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV(const PipeMaterial *pm, void *args)

{

    PL_SensetimeFaceTrackMultiTrd_Internal *in = (PL_SensetimeFaceTrackMultiTrd_Internal *) args;



    if (pm->type != PipeMaterial::PMT_FRAME) {

   if (pm->type != PipeMaterial::PMT_FRAME)

   {

        LOG_ERROR << "Only support PMT_FRAME" << LOG_ENDL;

        return false;

    }

@@ -391,23 +444,24 @@
        return false;



    MB_Frame *frame = (MB_Frame *) pm->buffer;

    if (frame->type != MB_Frame::MBFT_YUV420 && frame->type != MB_Frame::MBFT_NV12) {

   if (frame->type != MB_Frame::MBFT_YUV420 && frame->type != MB_Frame::MBFT_NV12)

   {

        LOG_ERROR << "Only support MBFT_YUV420 and MBFT_NV12" << LOG_ENDL;

        return false;

    }



    int res = 0;

    if (frame->type == MB_Frame::MBFT_YUV420)

        res = doFaceTrack(in, (uint8_t *) frame->buffer, frame->width, frame->height,

                                 frame->width, CV_PIX_FMT_YUV420P);

      res = doFaceTrack(in, (uint8_t *) frame->buffer, frame->width, frame->height, frame->width, CV_PIX_FMT_YUV420P);

    else if (frame->type == MB_Frame::MBFT_NV12)

        res = doFaceTrack(in, (uint8_t *) frame->buffer, frame->width, frame->height,

                                 frame->width, CV_PIX_FMT_NV12);

      res = doFaceTrack(in, (uint8_t *) frame->buffer, frame->width, frame->height, frame->width, CV_PIX_FMT_NV12);



    if (res < 0) {

   if (res < 0)

   {

        in->payError = true;

        return false;

    } else

   }

   else

        in->payError = false;



    //in->buffer readly

@@ -422,40 +476,42 @@
    return false;

}



bool PL_SensetimeFaceTrackMultiTrd::pay(const PipeMaterial &pm) {

bool PL_SensetimeFaceTrackMultiTrd::pay(const PipeMaterial &pm)

{

    PL_SensetimeFaceTrackMultiTrd_Internal *in = (PL_SensetimeFaceTrackMultiTrd_Internal *) internal;

    //LOG_ERROR << "PL_SensetimeFaceTrackMultiTrd pay" << LOG_ENDL;

    in->payError = true;

    if (in->payError)

        pm.breake(PipeMaterial::PMT_FRAME_LIST, MB_Frame::MBFT_YUV420,

                  PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);

      pm.breake(PipeMaterial::PMT_FRAME_LIST, MB_Frame::MBFT_YUV420, PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);

    if (in->payError)

        pm.breake(PipeMaterial::PMT_FRAME_LIST, MB_Frame::MBFT_NV12,

                  PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);

      pm.breake(PipeMaterial::PMT_FRAME_LIST, MB_Frame::MBFT_NV12, PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);

    if (in->payError)

        pm.breake(PipeMaterial::PMT_FRAME, MB_Frame::MBFT_YUV420,

                  PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);

      pm.breake(PipeMaterial::PMT_FRAME, MB_Frame::MBFT_YUV420, PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);

    if (in->payError)

        pm.breake(PipeMaterial::PMT_FRAME, MB_Frame::MBFT_NV12,

                  PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);

      pm.breake(PipeMaterial::PMT_FRAME, MB_Frame::MBFT_NV12, PL_SensetimeFaceTrackMultiTrd::pay_breaker_MBFT_YUV, in);



    in->frameCount++;

    return !(in->payError);

}



bool PL_SensetimeFaceTrackMultiTrd::gain(PipeMaterial &pm) {

bool PL_SensetimeFaceTrackMultiTrd::gain(PipeMaterial &pm)

{

    PL_SensetimeFaceTrackMultiTrd_Internal *in = (PL_SensetimeFaceTrackMultiTrd_Internal *) internal;

    in->trackThread.get_face_features(in->faceFeatures);

    if (in->payError) {

   if (in->payError)

   {

        pm.former = this;

        return false;

    }



    if (!in->trackThread.get_config()->generate_face_feature) {

   if (!in->trackThread.get_config()->generate_face_feature)

   {

        pm.type = PipeMaterial::PMT_FRAME;

        pm.buffer = &(in->lastFrame);

        pm.buffSize = 0;

    } else {

   }

   else

   {

        in->pmList[0].type = PipeMaterial::PMT_FRAME;

        in->pmList[0].buffer = &(in->lastFrame);

        in->pmList[0].buffSize = 0;

@@ -473,8 +529,4 @@


    pm.former = this;

    return true;

}



void *PL_SensetimeFaceTrackMultiTrd::pay_thd(void *arg) {



}