prograrm temp

旧城等待， 2023-01-17 13:51 110阅读 0赞

### 调试暂存 ###

*  2021.4.30:12:39temp
 *  new
 *  normal

# 2021.4.30:12:39temp #

/** * Copyright (c) 2017-2020, NVIDIA CORPORATION. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */
    
    #include <string.h>
    #include <string>
    #include <sstream>
    #include <iostream>
    #include <ostream>
    #include <fstream>
    #include "gstdsexample.h"
    #include <sys/time.h>
    
    
    #include "opencv2/core/core.hpp" 
    #include "opencv2/imgproc/imgproc.hpp" 
    #include "opencv2/calib3d/calib3d.hpp" 
    #include "opencv2/highgui/highgui.hpp" 
    using namespace cv;
    using namespace std;
    
    
    GST_DEBUG_CATEGORY_STATIC (gst_dsexample_debug);
    #define GST_CAT_DEFAULT gst_dsexample_debug
    #define USE_EGLIMAGE 1
    /* enable to write transformed cvmat to files */
    /* #define DSEXAMPLE_DEBUG */
    static GQuark _dsmeta_quark = 0;
    
    /* Enum to identify properties */
    enum
    { 
      PROP_0,
      PROP_UNIQUE_ID,
      PROP_PROCESSING_WIDTH,
      PROP_PROCESSING_HEIGHT,
      PROP_PROCESS_FULL_FRAME,
      PROP_BLUR_OBJECTS,
      PROP_GPU_DEVICE_ID
    };
    
    #define CHECK_NVDS_MEMORY_AND_GPUID(object, surface) \ ({ int _errtype=0;\ do { \ if ((surface->memType == NVBUF_MEM_DEFAULT || surface->memType == NVBUF_MEM_CUDA_DEVICE) && \ (surface->gpuId != object->gpu_id)) { \ GST_ELEMENT_ERROR (object, RESOURCE, FAILED, \ ("Input surface gpu-id doesnt match with configured gpu-id for element," \ " please allocate input using unified memory, or use same gpu-ids"),\ ("surface-gpu-id=%d,%s-gpu-id=%d",surface->gpuId,GST_ELEMENT_NAME(object),\ object->gpu_id)); \ _errtype = 1;\ } \ } while(0); \ _errtype; \ })
    
    
    /* Default values for properties */
    #define DEFAULT_UNIQUE_ID 15
    #define DEFAULT_PROCESSING_WIDTH 640
    #define DEFAULT_PROCESSING_HEIGHT 480
    #define DEFAULT_PROCESS_FULL_FRAME TRUE
    #define DEFAULT_BLUR_OBJECTS FALSE
    #define DEFAULT_GPU_ID 0
    
    #define RGB_BYTES_PER_PIXEL 3
    #define RGBA_BYTES_PER_PIXEL 4
    #define Y_BYTES_PER_PIXEL 1
    #define UV_BYTES_PER_PIXEL 2
    
    #define MIN_INPUT_OBJECT_WIDTH 16
    #define MIN_INPUT_OBJECT_HEIGHT 16
    
    
    /*畸变矫正相关*/
    #define SRC_WIDTH 1920
    #define SRC_HEIGHT 1080
    
    Mat mapx = Mat(Size(SRC_WIDTH, SRC_HEIGHT), CV_32FC1);
    Mat mapy = Mat(Size(SRC_WIDTH, SRC_HEIGHT), CV_32FC1);
    Mat newimage ; //校正后输出图片
    
    #define CHECK_NPP_STATUS(npp_status,error_str) do { \ if ((npp_status) != NPP_SUCCESS) { \ g_print ("Error: %s in %s at line %d: NPP Error %d\n", \ error_str, __FILE__, __LINE__, npp_status); \ goto error; \ } \ } while (0)
    
    #define CHECK_CUDA_STATUS(cuda_status,error_str) do { \ if ((cuda_status) != cudaSuccess) { \ g_print ("Error: %s in %s at line %d (%s)\n", \ error_str, __FILE__, __LINE__, cudaGetErrorName(cuda_status)); \ goto error; \ } \ } while (0)
    
    /* By default NVIDIA Hardware allocated memory flows through the pipeline. We * will be processing on this type of memory only. */
    #define GST_CAPS_FEATURE_MEMORY_NVMM "memory:NVMM"
    static GstStaticPadTemplate gst_dsexample_sink_template =
    GST_STATIC_PAD_TEMPLATE ("sink",
        GST_PAD_SINK,
        GST_PAD_ALWAYS,
        GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
            (GST_CAPS_FEATURE_MEMORY_NVMM,
                "{ NV12, RGBA, I420 }")));
    
    static GstStaticPadTemplate gst_dsexample_src_template =
    GST_STATIC_PAD_TEMPLATE ("src",
        GST_PAD_SRC,
        GST_PAD_ALWAYS,
        GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
            (GST_CAPS_FEATURE_MEMORY_NVMM,
                "{ NV12, RGBA, I420 }")));
    
    /* Define our element type. Standard GObject/GStreamer boilerplate stuff */
    #define gst_dsexample_parent_class parent_class
    G_DEFINE_TYPE (GstDsExample, gst_dsexample, GST_TYPE_BASE_TRANSFORM);
    
    static void gst_dsexample_set_property (GObject * object, guint prop_id,
        const GValue * value, GParamSpec * pspec);
    static void gst_dsexample_get_property (GObject * object, guint prop_id,
        GValue * value, GParamSpec * pspec);
    
    static gboolean gst_dsexample_set_caps (GstBaseTransform * btrans,
        GstCaps * incaps, GstCaps * outcaps);
    static gboolean gst_dsexample_start (GstBaseTransform * btrans);
    static gboolean gst_dsexample_stop (GstBaseTransform * btrans);
    
    static GstFlowReturn gst_dsexample_transform_ip (GstBaseTransform *
        btrans, GstBuffer * inbuf);
    
    static void
    attach_metadata_full_frame (GstDsExample * dsexample, NvDsFrameMeta *frame_meta,
        gdouble scale_ratio, DsExampleOutput * output, guint batch_id);
    static void attach_metadata_object (GstDsExample * dsexample,
        NvDsObjectMeta * obj_meta, DsExampleOutput * output);
    
    
    
    void InitMat(Mat& m, float* num)
    { 
    	for (int i = 0; i<m.rows; i++)
    	{ 
    		for (int j = 0; j<m.cols; j++)
    		{ 
    			m.at<float>(i, j) = *(num + i * m.rows + j);
    		}
    	}
    }
    
    void jiaozheng_init(void)
    { 
    	int OK = 0;
    
    
    	Mat R = Mat::eye(3, 3, CV_32F);
    	//参数矩阵
    	float neican_data[] = {  9558.649257742036, 0, 959.3165310990756, 0, 9435.752651759443, 532.7507141910969, 0, 0, 1 };
    	Mat cameraMatrix(3, 3, CV_32FC1);
    	InitMat(neican_data,cameraMatrix);
    
    	cout << "cameraMatrix= " << endl << " " << cameraMatrix << endl << endl;
    	//测得的畸变系数
    	float jibian_data[] = {  -6.956561513881647, -68.83902522804168, -0.004834538444671919, 0.01471273691928269, -0.4916103704308509 };
    	Mat distCoeffs(1, 5, CV_32FC1); /* 摄像机的5个畸变系数：k1,k2,p1,p2,k3 */
    	InitMat( jibian_data, distCoeffs);
    	cout << "distCoeffs= " << endl << " " << distCoeffs << endl << endl;
    
    	/********相机矫正*******************************************************************************/
    	//cout << "mapx= " << endl << " " << mapx << endl << endl;
    	//cout << "mapy= " << endl << " " << mapy << endl << endl;
    	initUndistortRectifyMap(cameraMatrix, distCoeffs, R, cameraMatrix, Size(SRC_WIDTH, SRC_HEIGHT), CV_32FC1, mapx, mapy);
    	//cout << "mapx= " << endl << " " << mapx << endl << endl;
    	//cout << "mapy= " << endl << " " << mapy << endl << endl;
    
    }
    
    
    
    
    
    
    /******************************************************************************* Function: jibianjiaozheng Description: 该函数实现畸变矫正 Input: 原图 Output: 畸变矫正后的图片 Return: 0: Successful ohters: Failed *******************************************************************************/
    
    int jibianjiaozheng(Mat src_picture, Mat & dst_picture)
    { 
    	int OK = 0;
    	static unsigned int INIT_MAT_OK = 1;
    
    	if (INIT_MAT_OK)
    	{ 
    		newimage = src_picture.clone(); //校正后输出图片
    		INIT_MAT_OK = 0;
    	}
    
    	remap(src_picture, newimage, mapx, mapy, INTER_LINEAR);
    	dst_picture= newimage+1;
    	return OK;
    }
    
    
    
    
    
    
    /* Install properties, set sink and src pad capabilities, override the required * functions of the base class, These are common to all instances of the * element. */
    static void
    gst_dsexample_class_init (GstDsExampleClass * klass)
    { 
      GObjectClass *gobject_class;
      GstElementClass *gstelement_class;
      GstBaseTransformClass *gstbasetransform_class;
    
      /* Indicates we want to use DS buf api */
      g_setenv ("DS_NEW_BUFAPI", "1", TRUE);
    
      gobject_class = (GObjectClass *) klass;
      gstelement_class = (GstElementClass *) klass;
      gstbasetransform_class = (GstBaseTransformClass *) klass;
    
      /* Overide base class functions */
      gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_dsexample_set_property);
      gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_dsexample_get_property);
    
      gstbasetransform_class->set_caps = GST_DEBUG_FUNCPTR (gst_dsexample_set_caps);
      gstbasetransform_class->start = GST_DEBUG_FUNCPTR (gst_dsexample_start);
      gstbasetransform_class->stop = GST_DEBUG_FUNCPTR (gst_dsexample_stop);
    
      gstbasetransform_class->transform_ip =
          GST_DEBUG_FUNCPTR (gst_dsexample_transform_ip);
    
      /* Install properties */
      g_object_class_install_property (gobject_class, PROP_UNIQUE_ID,
          g_param_spec_uint ("unique-id",
              "Unique ID",
              "Unique ID for the element. Can be used to identify output of the"
              " element", 0, G_MAXUINT, DEFAULT_UNIQUE_ID, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESSING_WIDTH,
          g_param_spec_int ("processing-width",
              "Processing Width",
              "Width of the input buffer to algorithm",
              1, G_MAXINT, DEFAULT_PROCESSING_WIDTH, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESSING_HEIGHT,
          g_param_spec_int ("processing-height",
              "Processing Height",
              "Height of the input buffer to algorithm",
              1, G_MAXINT, DEFAULT_PROCESSING_HEIGHT, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESS_FULL_FRAME,
          g_param_spec_boolean ("full-frame",
              "Full frame",
              "Enable to process full frame or disable to process objects detected"
              "by primary detector", DEFAULT_PROCESS_FULL_FRAME, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_BLUR_OBJECTS,
          g_param_spec_boolean ("blur-objects",
              "Blur Objects",
              "Enable to blur the objects detected in full-frame=0 mode"
              "by primary detector", DEFAULT_BLUR_OBJECTS, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_GPU_DEVICE_ID,
          g_param_spec_uint ("gpu-id",
              "Set GPU Device ID",
              "Set GPU Device ID", 0,
              G_MAXUINT, 0,
              GParamFlags
              (G_PARAM_READWRITE |
                  G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY)));
      /* Set sink and src pad capabilities */
      gst_element_class_add_pad_template (gstelement_class,
          gst_static_pad_template_get (&gst_dsexample_src_template));
      gst_element_class_add_pad_template (gstelement_class,
          gst_static_pad_template_get (&gst_dsexample_sink_template));
    
      /* Set metadata describing the element */
      gst_element_class_set_details_simple (gstelement_class,
          "DsExample plugin",
          "DsExample Plugin",
          "Process a 3rdparty example algorithm on objects / full frame",
          "NVIDIA Corporation. Post on Deepstream for Tesla forum for any queries "
          "@ https://devtalk.nvidia.com/default/board/209/");
    }
    
    static void
    gst_dsexample_init (GstDsExample * dsexample)
    { 
      GstBaseTransform *btrans = GST_BASE_TRANSFORM (dsexample);
    
      /* We will not be generating a new buffer. Just adding / updating * metadata. */
      gst_base_transform_set_in_place (GST_BASE_TRANSFORM (btrans), TRUE);
      /* We do not want to change the input caps. Set to passthrough. transform_ip * is still called. */
      gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (btrans), TRUE);
    
      /* Initialize all property variables to default values */
      dsexample->unique_id = DEFAULT_UNIQUE_ID;
      dsexample->processing_width = DEFAULT_PROCESSING_WIDTH;
      dsexample->processing_height = DEFAULT_PROCESSING_HEIGHT;
      dsexample->process_full_frame = DEFAULT_PROCESS_FULL_FRAME;
      dsexample->blur_objects = DEFAULT_BLUR_OBJECTS;
      dsexample->gpu_id = DEFAULT_GPU_ID;
      /* This quark is required to identify NvDsMeta when iterating through * the buffer metadatas */
      if (!_dsmeta_quark)
        _dsmeta_quark = g_quark_from_static_string (NVDS_META_STRING);
    }
    
    /* Function called when a property of the element is set. Standard boilerplate. */
    static void
    gst_dsexample_set_property (GObject * object, guint prop_id,
        const GValue * value, GParamSpec * pspec)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (object);
      switch (prop_id) { 
        case PROP_UNIQUE_ID:
          dsexample->unique_id = g_value_get_uint (value);
          break;
        case PROP_PROCESSING_WIDTH:
          dsexample->processing_width = g_value_get_int (value);
          break;
        case PROP_PROCESSING_HEIGHT:
          dsexample->processing_height = g_value_get_int (value);
          break;
        case PROP_PROCESS_FULL_FRAME:
          dsexample->process_full_frame = g_value_get_boolean (value);
          break;
        case PROP_BLUR_OBJECTS:
          dsexample->blur_objects = g_value_get_boolean (value);
          break;
        case PROP_GPU_DEVICE_ID:
          dsexample->gpu_id = g_value_get_uint (value);
          break;
        default:
          G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
          break;
      }
    }
    
    /* Function called when a property of the element is requested. Standard * boilerplate. */
    static void
    gst_dsexample_get_property (GObject * object, guint prop_id,
        GValue * value, GParamSpec * pspec)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (object);
    
      switch (prop_id) { 
        case PROP_UNIQUE_ID:
          g_value_set_uint (value, dsexample->unique_id);
          break;
        case PROP_PROCESSING_WIDTH:
          g_value_set_int (value, dsexample->processing_width);
          break;
        case PROP_PROCESSING_HEIGHT:
          g_value_set_int (value, dsexample->processing_height);
          break;
        case PROP_PROCESS_FULL_FRAME:
          g_value_set_boolean (value, dsexample->process_full_frame);
          break;
        case PROP_BLUR_OBJECTS:
          g_value_set_boolean (value, dsexample->blur_objects);
          break;
        case PROP_GPU_DEVICE_ID:
          g_value_set_uint (value, dsexample->gpu_id);
          break;
        default:
          G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
          break;
      }
    }
    
    /** * Initialize all resources and start the output thread */
    static gboolean
    gst_dsexample_start (GstBaseTransform * btrans)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      NvBufSurfaceCreateParams create_params;
      DsExampleInitParams init_params =
          {  dsexample->processing_width, dsexample->processing_height,
        dsexample->process_full_frame
      };
    
      GstQuery *queryparams = NULL;
      guint batch_size = 1;
    
      /* Algorithm specific initializations and resource allocation. */
      dsexample->dsexamplelib_ctx = DsExampleCtxInit (&init_params);
    
      GST_DEBUG_OBJECT (dsexample, "ctx lib %p \n", dsexample->dsexamplelib_ctx);
    
      CHECK_CUDA_STATUS (cudaSetDevice (dsexample->gpu_id),
          "Unable to set cuda device");
    
      dsexample->batch_size = 1;
      queryparams = gst_nvquery_batch_size_new ();
      if (gst_pad_peer_query (GST_BASE_TRANSFORM_SINK_PAD (btrans), queryparams)
          || gst_pad_peer_query (GST_BASE_TRANSFORM_SRC_PAD (btrans), queryparams)) { 
        if (gst_nvquery_batch_size_parse (queryparams, &batch_size)) { 
          dsexample->batch_size = batch_size;
        }
      }
      GST_DEBUG_OBJECT (dsexample, "Setting batch-size %d \n",
          dsexample->batch_size);
      gst_query_unref (queryparams);
    
      if (dsexample->process_full_frame && dsexample->blur_objects) { 
        GST_ERROR ("Error: does not support blurring while processing full frame");
        goto error;
      }
    
      CHECK_CUDA_STATUS (cudaStreamCreate (&dsexample->cuda_stream),
          "Could not create cuda stream");
    
      if (dsexample->inter_buf)
        NvBufSurfaceDestroy (dsexample->inter_buf);
      dsexample->inter_buf = NULL;
    
      /* An intermediate buffer for NV12/RGBA to BGR conversion will be * required. Can be skipped if custom algorithm can work directly on NV12/RGBA. */
      create_params.gpuId  = dsexample->gpu_id;
      create_params.width  = dsexample->processing_width;
      create_params.height = dsexample->processing_height;
      create_params.size = 0;
      create_params.colorFormat = NVBUF_COLOR_FORMAT_RGBA;
      create_params.layout = NVBUF_LAYOUT_PITCH;
    #ifdef __aarch64__
      create_params.memType = NVBUF_MEM_DEFAULT;
    #else
      create_params.memType = NVBUF_MEM_CUDA_UNIFIED;
    #endif
    
      if (NvBufSurfaceCreate (&dsexample->inter_buf, 1,
              &create_params) != 0) { 
        GST_ERROR ("Error: Could not allocate internal buffer for dsexample");
        goto error;
      }
    
      /* Create host memory for storing converted/scaled interleaved RGB data */
      CHECK_CUDA_STATUS (cudaMallocHost (&dsexample->host_rgb_buf,
              dsexample->processing_width * dsexample->processing_height *
              RGB_BYTES_PER_PIXEL), "Could not allocate cuda host buffer");
    
      GST_DEBUG_OBJECT (dsexample, "allocated cuda buffer %p \n",
          dsexample->host_rgb_buf);
    
      /* CV Mat containing interleaved RGB data. This call does not allocate memory. * It uses host_rgb_buf as data. */
      dsexample->cvmat =
          new cv::Mat (dsexample->processing_height, dsexample->processing_width,
          CV_8UC3, dsexample->host_rgb_buf,
          dsexample->processing_width * RGB_BYTES_PER_PIXEL);
    
      if (!dsexample->cvmat)
        goto error;
    
      GST_DEBUG_OBJECT (dsexample, "created CV Mat\n");
    
      return TRUE;
    error:
      if (dsexample->host_rgb_buf) { 
        cudaFreeHost (dsexample->host_rgb_buf);
        dsexample->host_rgb_buf = NULL;
      }
    
      if (dsexample->cuda_stream) { 
        cudaStreamDestroy (dsexample->cuda_stream);
        dsexample->cuda_stream = NULL;
      }
      if (dsexample->dsexamplelib_ctx)
        DsExampleCtxDeinit (dsexample->dsexamplelib_ctx);
      return FALSE;
    }
    
    /** * Stop the output thread and free up all the resources */
    static gboolean
    gst_dsexample_stop (GstBaseTransform * btrans)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
    
      if (dsexample->inter_buf)
        NvBufSurfaceDestroy(dsexample->inter_buf);
      dsexample->inter_buf = NULL;
    
      if (dsexample->cuda_stream)
        cudaStreamDestroy (dsexample->cuda_stream);
      dsexample->cuda_stream = NULL;
    
      delete dsexample->cvmat;
      dsexample->cvmat = NULL;
    
      if (dsexample->host_rgb_buf) { 
        cudaFreeHost (dsexample->host_rgb_buf);
        dsexample->host_rgb_buf = NULL;
      }
    
      GST_DEBUG_OBJECT (dsexample, "deleted CV Mat \n");
    
      /* Deinit the algorithm library */
      DsExampleCtxDeinit (dsexample->dsexamplelib_ctx);
      dsexample->dsexamplelib_ctx = NULL;
    
      GST_DEBUG_OBJECT (dsexample, "ctx lib released \n");
    
      return TRUE;
    }
    
    /** * Called when source / sink pad capabilities have been negotiated. */
    static gboolean
    gst_dsexample_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
        GstCaps * outcaps)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      /* Save the input video information, since this will be required later. */
      gst_video_info_from_caps (&dsexample->video_info, incaps);
    
      if (dsexample->blur_objects && !dsexample->process_full_frame) { 
        /* requires RGBA format for blurring the objects in opencv */
         if (dsexample->video_info.finfo->format != GST_VIDEO_FORMAT_RGBA) { 
          GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
              ("input format should be RGBA when using blur-objects property"), (NULL));
          goto error;
          }
      }
    
      return TRUE;
    
    error:
      return FALSE;
    }
    
    /** * Scale the entire frame to the processing resolution maintaining aspect ratio. * Or crop and scale objects to the processing resolution maintaining the aspect * ratio. Remove the padding required by hardware and convert from RGBA to RGB * using openCV. These steps can be skipped if the algorithm can work with * padded data and/or can work with RGBA. */
    static GstFlowReturn
    get_converted_mat (GstDsExample * dsexample, NvBufSurface *input_buf, gint idx,
        NvOSD_RectParams * crop_rect_params, gdouble & ratio, gint input_width,
        gint input_height)
    { 
      NvBufSurfTransform_Error err;
      NvBufSurfTransformConfigParams transform_config_params;
      NvBufSurfTransformParams transform_params;
      NvBufSurfTransformRect src_rect;
      NvBufSurfTransformRect dst_rect;
      NvBufSurface ip_surf;
      cv::Mat in_mat;
      ip_surf = *input_buf;
    
      ip_surf.numFilled = ip_surf.batchSize = 1;
      ip_surf.surfaceList = &(input_buf->surfaceList[idx]);
    
      gint src_left = GST_ROUND_UP_2((unsigned int)crop_rect_params->left);
      gint src_top = GST_ROUND_UP_2((unsigned int)crop_rect_params->top);
      gint src_width = GST_ROUND_DOWN_2((unsigned int)crop_rect_params->width);
      gint src_height = GST_ROUND_DOWN_2((unsigned int)crop_rect_params->height);
    
      /* Maintain aspect ratio */
      double hdest = dsexample->processing_width * src_height / (double) src_width;
      double wdest = dsexample->processing_height * src_width / (double) src_height;
      guint dest_width, dest_height;
    
      if (hdest <= dsexample->processing_height) { 
        dest_width = dsexample->processing_width;
        dest_height = hdest;
      } else { 
        dest_width = wdest;
        dest_height = dsexample->processing_height;
      }
    
      /* Configure transform session parameters for the transformation */
      transform_config_params.compute_mode = NvBufSurfTransformCompute_Default;
      transform_config_params.gpu_id = dsexample->gpu_id;
      transform_config_params.cuda_stream = dsexample->cuda_stream;
    
      /* Set the transform session parameters for the conversions executed in this * thread. */
      err = NvBufSurfTransformSetSessionParams (&transform_config_params);
      if (err != NvBufSurfTransformError_Success) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvBufSurfTransformSetSessionParams failed with error %d", err), (NULL));
        goto error;
      }
    
      /* Calculate scaling ratio while maintaining aspect ratio */
      ratio = MIN (1.0 * dest_width/ src_width, 1.0 * dest_height / src_height);
    
      if ((crop_rect_params->width == 0) || (crop_rect_params->height == 0)) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("%s:crop_rect_params dimensions are zero",__func__), (NULL));
        goto error;
      }
    
    #ifdef __aarch64__
      if (ratio <= 1.0 / 16 || ratio >= 16.0) { 
        /* Currently cannot scale by ratio > 16 or < 1/16 for Jetson */
        goto error;
      }
    #endif
      /* Set the transform ROIs for source and destination */
      src_rect = { (guint)src_top, (guint)src_left, (guint)src_width, (guint)src_height};
      dst_rect = { 0, 0, (guint)dest_width, (guint)dest_height};
    
      /* Set the transform parameters */
      transform_params.src_rect = &src_rect;
      transform_params.dst_rect = &dst_rect;
      transform_params.transform_flag =
        NVBUFSURF_TRANSFORM_FILTER | NVBUFSURF_TRANSFORM_CROP_SRC |
          NVBUFSURF_TRANSFORM_CROP_DST;
      transform_params.transform_filter = NvBufSurfTransformInter_Default;
    
      /* Memset the memory */
      NvBufSurfaceMemSet (dsexample->inter_buf, 0, 0, 0);
    
      GST_DEBUG_OBJECT (dsexample, "Scaling and converting input buffer\n");
    
      /* Transformation scaling+format conversion if any. */
      err = NvBufSurfTransform (&ip_surf, dsexample->inter_buf, &transform_params);
      if (err != NvBufSurfTransformError_Success) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvBufSurfTransform failed with error %d while converting buffer", err),
            (NULL));
        goto error;
      }
      /* Map the buffer so that it can be accessed by CPU */
      if (NvBufSurfaceMap (dsexample->inter_buf, 0, 0, NVBUF_MAP_READ) != 0){ 
        goto error;
      }
    
      /* Cache the mapped data for CPU access */
      NvBufSurfaceSyncForCpu (dsexample->inter_buf, 0, 0);
    
      /* Use openCV to remove padding and convert RGBA to BGR. Can be skipped if * algorithm can handle padded RGBA data. */
      in_mat =
          cv::Mat (dsexample->processing_height, dsexample->processing_width,
          CV_8UC4, dsexample->inter_buf->surfaceList[0].mappedAddr.addr[0],
          dsexample->inter_buf->surfaceList[0].pitch);
    
    #if (CV_MAJOR_VERSION >= 4)
      cv::cvtColor (in_mat, *dsexample->cvmat, cv::COLOR_RGBA2BGR);
    #else
      cv::cvtColor (in_mat, *dsexample->cvmat, CV_RGBA2BGR);
    #endif
    
      if (NvBufSurfaceUnMap (dsexample->inter_buf, 0, 0)){ 
        goto error;
      }
    
    #ifdef __aarch64__
      /* To use the converted buffer in CUDA, create an EGLImage and then use * CUDA-EGL interop APIs */
      if (USE_EGLIMAGE) { 
        if (NvBufSurfaceMapEglImage (dsexample->inter_buf, 0) !=0 ) { 
          goto error;
        }
    
        /* dsexample->inter_buf->surfaceList[0].mappedAddr.eglImage * Use interop APIs cuGraphicsEGLRegisterImage and * cuGraphicsResourceGetMappedEglFrame to access the buffer in CUDA */
    
        /* Destroy the EGLImage */
        NvBufSurfaceUnMapEglImage (dsexample->inter_buf, 0);
      }
    #endif
    
      /* We will first convert only the Region of Interest (the entire frame or the * object bounding box) to RGB and then scale the converted RGB frame to * processing resolution. */
      return GST_FLOW_OK;
    
    error:
      return GST_FLOW_ERROR;
    }
    
    #if 0
    /* * Blur the detected objects when processing in object mode (full-frame=0) */
    static GstFlowReturn
    blur_objects (GstDsExample * dsexample, gint idx,
        NvOSD_RectParams * crop_rect_params, cv::Mat in_mat)
    { 
      cv::Rect crop_rect;
      if ((crop_rect_params->width == 0) || (crop_rect_params->height == 0)) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("%s:crop_rect_params dimensions are zero",__func__), (NULL));
        return GST_FLOW_ERROR;
      }
    
    /* rectangle for cropped objects */
      crop_rect = cv::Rect (crop_rect_params->left, crop_rect_params->top,
      crop_rect_params->width, crop_rect_params->height);
    
    /* apply gaussian blur to the detected objects */
      GaussianBlur(in_mat(crop_rect), in_mat(crop_rect), cv::Size(15,15), 4);
      return GST_FLOW_OK;
    }
    
    #endif
    /* * Blur the detected objects when processing in object mode (full-frame=0) */
    static GstFlowRetur blur_objects (GstDsExample * dsexample, gint idx,
        NvOSD_RectParams * crop_rect_params, cv::Mat in_mat)
    { 
    	int hrst=1;
    	cv::Rect crop_rect;
    	static unsigned int jiaozheng_init_flag = 0;
    	if ((crop_rect_params->width == 0) || (crop_rect_params->height == 0)) 
    	{ 
    		GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
    		("%s:crop_rect_params dimensions are zero",__func__), (NULL));
    		return GST_FLOW_ERROR;
    	}
    	steady_clock::time_point t1 = steady_clock::now();
    	if (!jiaozheng_init_flag)
    	{ 
    		printf("初始化\n");
    		jiaozheng_init();
    		jiaozheng_init_flag = 1;
    	}
    	hrst = jibianjiaozheng(in_mat, in_mat);
    	if (hrst != 0)
    	{ 
    		printf("畸变矫正失败\n");
    	}
    	else
    	{ 
    		//printf("畸变矫正成功\n");
    	}
    	/*time cost calc code */
    	steady_clock::time_point t2 = steady_clock::now();
    	duration<double> time_used = duration_cast<duration<double>>(t2 - t1);
    	cout<" time cost= "<< (time_used.count() * 1000) <<" ms."<<endl;
    
    	return GST_FLOW_OK;
    }
    
    
    
    /** * Called when element recieves an input buffer from upstream element. */
    static GstFlowReturn
    gst_dsexample_transform_ip (GstBaseTransform * btrans, GstBuffer * inbuf)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      GstMapInfo in_map_info;
      GstFlowReturn flow_ret = GST_FLOW_ERROR;
      gdouble scale_ratio = 1.0;
      DsExampleOutput *output;
    
      NvBufSurface *surface = NULL;
      NvDsBatchMeta *batch_meta = NULL;
      NvDsFrameMeta *frame_meta = NULL;
      NvDsMetaList * l_frame = NULL;
      guint i = 0;
    
      dsexample->frame_num++;
      CHECK_CUDA_STATUS (cudaSetDevice (dsexample->gpu_id),
          "Unable to set cuda device");
    
      memset (&in_map_info, 0, sizeof (in_map_info));
      if (!gst_buffer_map (inbuf, &in_map_info, GST_MAP_READ)) { 
        g_print ("Error: Failed to map gst buffer\n");
        goto error;
      }
    
      nvds_set_input_system_timestamp (inbuf, GST_ELEMENT_NAME (dsexample));
      surface = (NvBufSurface *) in_map_info.data;
      GST_DEBUG_OBJECT (dsexample,
          "Processing Frame %" G_GUINT64_FORMAT " Surface %p\n",
          dsexample->frame_num, surface);
    
      if (CHECK_NVDS_MEMORY_AND_GPUID (dsexample, surface))
        goto error;
    
      batch_meta = gst_buffer_get_nvds_batch_meta (inbuf);
      if (batch_meta == nullptr) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvDsBatchMeta not found for input buffer."), (NULL));
        return GST_FLOW_ERROR;
      }
    
      if (dsexample->process_full_frame) { 
        for (l_frame = batch_meta->frame_meta_list; l_frame != NULL;
          l_frame = l_frame->next)
        { 
          frame_meta = (NvDsFrameMeta *) (l_frame->data);
          NvOSD_RectParams rect_params;
    
          /* Scale the entire frame to processing resolution */
          rect_params.left = 0;
          rect_params.top = 0;
          rect_params.width = dsexample->video_info.width;
          rect_params.height = dsexample->video_info.height;
    
          /* Scale and convert the frame */
          if (get_converted_mat (dsexample, surface, i, &rect_params,
                scale_ratio, dsexample->video_info.width,
                dsexample->video_info.height) != GST_FLOW_OK) { 
            goto error;
          }
    
          /* Process to get the output */
          output =
              DsExampleProcess (dsexample->dsexamplelib_ctx,
              dsexample->cvmat->data);
          /* Attach the metadata for the full frame */
          attach_metadata_full_frame (dsexample, frame_meta, scale_ratio, output, i);
          i++;
          free (output);
        }	
    
    
      } else { 
        /* Using object crops as input to the algorithm. The objects are detected by * the primary detector */
        NvDsMetaList * l_obj = NULL;
        NvDsObjectMeta *obj_meta = NULL;
    
    #ifndef __aarch64__
        if (dsexample->blur_objects) { 
          if (surface->memType != NVBUF_MEM_CUDA_UNIFIED){ 
            GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                ("%s:need NVBUF_MEM_CUDA_UNIFIED memory for opencv blurring",__func__), (NULL));
            return GST_FLOW_ERROR;
          }
        }
    #endif
    
        for (l_frame = batch_meta->frame_meta_list; l_frame != NULL;
          l_frame = l_frame->next)
        { 
          frame_meta = (NvDsFrameMeta *) (l_frame->data);
          cv::Mat in_mat;
    
          if (dsexample->blur_objects) { 
            /* Map the buffer so that it can be accessed by CPU */
            if (surface->surfaceList[frame_meta->batch_id].mappedAddr.addr[0] == NULL){ 
              if (NvBufSurfaceMap (surface, frame_meta->batch_id, 0, NVBUF_MAP_READ_WRITE) != 0){ 
                GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                    ("%s:buffer map to be accessed by CPU failed", __func__), (NULL));
                return GST_FLOW_ERROR;
              }
            }
    
            /* Cache the mapped data for CPU access */
            NvBufSurfaceSyncForCpu (surface, frame_meta->batch_id, 0);
    
            in_mat =
                cv::Mat (surface->surfaceList[frame_meta->batch_id].planeParams.height[0],
                surface->surfaceList[frame_meta->batch_id].planeParams.width[0], CV_8UC4,
                surface->surfaceList[frame_meta->batch_id].mappedAddr.addr[0],
                surface->surfaceList[frame_meta->batch_id].planeParams.pitch[0]);
          }
    
          for (l_obj = frame_meta->obj_meta_list; l_obj != NULL;
              l_obj = l_obj->next)
          { 
            obj_meta = (NvDsObjectMeta *) (l_obj->data);
    
            if (dsexample->blur_objects) { 
              /* gaussian blur the detected objects using opencv */
              if (blur_objects (dsexample, frame_meta->batch_id,
                &obj_meta->rect_params, in_mat) != GST_FLOW_OK) { 
              /* Error in blurring, skip processing on object. */
                GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                ("blurring the object failed"), (NULL));
                if (NvBufSurfaceUnMap (surface, frame_meta->batch_id, 0)){ 
                  GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                    ("%s:buffer unmap to be accessed by CPU failed", __func__), (NULL));
                }
                return GST_FLOW_ERROR;
              }
              continue;
            }
    
            /* Should not process on objects smaller than MIN_INPUT_OBJECT_WIDTH x MIN_INPUT_OBJECT_HEIGHT * since it will cause hardware scaling issues. */
            if (obj_meta->rect_params.width < MIN_INPUT_OBJECT_WIDTH ||
                obj_meta->rect_params.height < MIN_INPUT_OBJECT_HEIGHT)
              continue;
    
            /* Crop and scale the object */
            if (get_converted_mat (dsexample,
                  surface, frame_meta->batch_id, &obj_meta->rect_params,
                  scale_ratio, dsexample->video_info.width,
                  dsexample->video_info.height) != GST_FLOW_OK) { 
              /* Error in conversion, skip processing on object. */
              continue;
            }
    
            /* Process the object crop to obtain label */
            output = DsExampleProcess (dsexample->dsexamplelib_ctx,
                dsexample->cvmat->data);
    
            /* Attach labels for the object */
            attach_metadata_object (dsexample, obj_meta, output);
    
            free (output);
          }
    
          if (dsexample->blur_objects) { 
          /* Cache the mapped data for device access */
            NvBufSurfaceSyncForDevice (surface, frame_meta->batch_id, 0);
    
    #ifdef DSEXAMPLE_DEBUG
            /* Use openCV to remove padding and convert RGBA to BGR. Can be skipped if * algorithm can handle padded RGBA data. */
    #if (CV_MAJOR_VERSION >= 4)
            cv::cvtColor (in_mat, *dsexample->cvmat, cv::COLOR_RGBA2BGR);
    #else
            cv::cvtColor (in_mat, *dsexample->cvmat, CV_RGBA2BGR);
    #endif
            /* used to dump the converted mat to files for debug */
            static guint cnt = 0;
            cv::imwrite("out_" + std::to_string (cnt) + ".jpeg", *dsexample->cvmat);
            cnt++;
    #endif
          }
        }
      }
      flow_ret = GST_FLOW_OK;
    
    error:
    
      nvds_set_output_system_timestamp (inbuf, GST_ELEMENT_NAME (dsexample));
      gst_buffer_unmap (inbuf, &in_map_info);
      return flow_ret;
    }
    
    /** * Attach metadata for the full frame. We will be adding a new metadata. */
    static void
    attach_metadata_full_frame (GstDsExample * dsexample, NvDsFrameMeta *frame_meta,
        gdouble scale_ratio, DsExampleOutput * output, guint batch_id)
    { 
      NvDsBatchMeta *batch_meta = frame_meta->base_meta.batch_meta;
      NvDsObjectMeta *object_meta = NULL;
      static gchar font_name[] = "Serif";
      GST_DEBUG_OBJECT (dsexample, "Attaching metadata %d\n", output->numObjects);
    
      for (gint i = 0; i < output->numObjects; i++) { 
        DsExampleObject *obj = &output->object[i];
        object_meta = nvds_acquire_obj_meta_from_pool(batch_meta);
        NvOSD_RectParams & rect_params = object_meta->rect_params;
        NvOSD_TextParams & text_params = object_meta->text_params;
    
        /* Assign bounding box coordinates */
        rect_params.left = obj->left;
        rect_params.top = obj->top;
        rect_params.width = obj->width;
        rect_params.height = obj->height;
    
        /* Semi-transparent yellow background */
        rect_params.has_bg_color = 0;
        rect_params.bg_color = (NvOSD_ColorParams) { 
        1, 1, 0, 0.4};
        /* Red border of width 6 */
        rect_params.border_width = 3;
        rect_params.border_color = (NvOSD_ColorParams) { 
        1, 0, 0, 1};
    
        /* Scale the bounding boxes proportionally based on how the object/frame was * scaled during input */
        rect_params.left /= scale_ratio;
        rect_params.top /= scale_ratio;
        rect_params.width /= scale_ratio;
        rect_params.height /= scale_ratio;
        GST_DEBUG_OBJECT (dsexample, "Attaching rect%d of batch%u"
            " left->%f top->%f width->%f"
            " height->%f label->%s\n", i, batch_id, rect_params.left,
            rect_params.top, rect_params.width, rect_params.height, obj->label);
    
        object_meta->object_id = UNTRACKED_OBJECT_ID;
        g_strlcpy (object_meta->obj_label, obj->label, MAX_LABEL_SIZE);
        /* display_text required heap allocated memory */
        text_params.display_text = g_strdup (obj->label);
        /* Display text above the left top corner of the object */
        text_params.x_offset = rect_params.left;
        text_params.y_offset = rect_params.top - 10;
        /* Set black background for the text */
        text_params.set_bg_clr = 1;
        text_params.text_bg_clr = (NvOSD_ColorParams) { 
        0, 0, 0, 1};
        /* Font face, size and color */
        text_params.font_params.font_name = font_name;
        text_params.font_params.font_size = 11;
        text_params.font_params.font_color = (NvOSD_ColorParams) { 
        1, 1, 1, 1};
    
        nvds_add_obj_meta_to_frame(frame_meta, object_meta, NULL);
        frame_meta->bInferDone = TRUE;
      }
    }
    
    /** * Only update string label in an existing object metadata. No bounding boxes. * We assume only one label per object is generated */
    static void
    attach_metadata_object (GstDsExample * dsexample, NvDsObjectMeta * obj_meta,
        DsExampleOutput * output)
    { 
      if (output->numObjects == 0)
        return;
      NvDsBatchMeta *batch_meta = obj_meta->base_meta.batch_meta;
    
      NvDsClassifierMeta *classifier_meta =
        nvds_acquire_classifier_meta_from_pool (batch_meta);
    
      classifier_meta->unique_component_id = dsexample->unique_id;
    
      NvDsLabelInfo *label_info =
        nvds_acquire_label_info_meta_from_pool (batch_meta);
      g_strlcpy (label_info->result_label, output->object[0].label, MAX_LABEL_SIZE);
      nvds_add_label_info_meta_to_classifier(classifier_meta, label_info);
      nvds_add_classifier_meta_to_object (obj_meta, classifier_meta);
    
      nvds_acquire_meta_lock (batch_meta);
      NvOSD_TextParams & text_params = obj_meta->text_params;
      NvOSD_RectParams & rect_params = obj_meta->rect_params;
    
      /* Below code to display the result */
      /* Set black background for the text * display_text required heap allocated memory */
      if (text_params.display_text) { 
        gchar *conc_string = g_strconcat (text_params.display_text, " ",
            output->object[0].label, NULL);
        g_free (text_params.display_text);
        text_params.display_text = conc_string;
      } else { 
        /* Display text above the left top corner of the object */
        text_params.x_offset = rect_params.left;
        text_params.y_offset = rect_params.top - 10;
        text_params.display_text = g_strdup (output->object[0].label);
        /* Font face, size and color */
        text_params.font_params.font_name = (char *)"Serif";
        text_params.font_params.font_size = 11;
        text_params.font_params.font_color = (NvOSD_ColorParams) { 
        1, 1, 1, 1};
        /* Set black background for the text */
        text_params.set_bg_clr = 1;
        text_params.text_bg_clr = (NvOSD_ColorParams) { 
        0, 0, 0, 1};
      }
      nvds_release_meta_lock (batch_meta);
    }
    
    /** * Boiler plate for registering a plugin and an element. */
    static gboolean
    dsexample_plugin_init (GstPlugin * plugin)
    { 
      GST_DEBUG_CATEGORY_INIT (gst_dsexample_debug, "dsexample", 0,
          "dsexample plugin");
    
      return gst_element_register (plugin, "dsexample", GST_RANK_PRIMARY,
          GST_TYPE_DSEXAMPLE);
    }
    
    GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
        GST_VERSION_MINOR,
        nvdsgst_dsexample,
        DESCRIPTION, dsexample_plugin_init, DS_VERSION, LICENSE, BINARY_PACKAGE, URL)

# new #

/** * Copyright (c) 2017-2020, NVIDIA CORPORATION. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */
    
    #include <string.h>
    #include <string>
    #include <sstream>
    #include <iostream>
    #include <ostream>
    #include <fstream>
    #include "gstdsexample.h"
    #include <sys/time.h>
    
    
    #include "opencv2/core/core.hpp" 
    #include "opencv2/imgproc/imgproc.hpp" 
    #include "opencv2/calib3d/calib3d.hpp" 
    #include "opencv2/highgui/highgui.hpp" 
    using namespace cv;
    using namespace std;
    
    
    GST_DEBUG_CATEGORY_STATIC (gst_dsexample_debug);
    #define GST_CAT_DEFAULT gst_dsexample_debug
    #define USE_EGLIMAGE 1
    /* enable to write transformed cvmat to files */
    /* #define DSEXAMPLE_DEBUG */
    static GQuark _dsmeta_quark = 0;
    
    /* Enum to identify properties */
    enum
    { 
      PROP_0,
      PROP_UNIQUE_ID,
      PROP_PROCESSING_WIDTH,
      PROP_PROCESSING_HEIGHT,
      PROP_PROCESS_FULL_FRAME,
      PROP_BLUR_OBJECTS,
      PROP_GPU_DEVICE_ID
    };
    
    #define CHECK_NVDS_MEMORY_AND_GPUID(object, surface) \ ({ int _errtype=0;\ do { \ if ((surface->memType == NVBUF_MEM_DEFAULT || surface->memType == NVBUF_MEM_CUDA_DEVICE) && \ (surface->gpuId != object->gpu_id)) { \ GST_ELEMENT_ERROR (object, RESOURCE, FAILED, \ ("Input surface gpu-id doesnt match with configured gpu-id for element," \ " please allocate input using unified memory, or use same gpu-ids"),\ ("surface-gpu-id=%d,%s-gpu-id=%d",surface->gpuId,GST_ELEMENT_NAME(object),\ object->gpu_id)); \ _errtype = 1;\ } \ } while(0); \ _errtype; \ })
    
    
    /* Default values for properties */
    #define DEFAULT_UNIQUE_ID 15
    #define DEFAULT_PROCESSING_WIDTH 640
    #define DEFAULT_PROCESSING_HEIGHT 480
    #define DEFAULT_PROCESS_FULL_FRAME TRUE
    #define DEFAULT_BLUR_OBJECTS FALSE
    #define DEFAULT_GPU_ID 0
    
    #define RGB_BYTES_PER_PIXEL 3
    #define RGBA_BYTES_PER_PIXEL 4
    #define Y_BYTES_PER_PIXEL 1
    #define UV_BYTES_PER_PIXEL 2
    
    #define MIN_INPUT_OBJECT_WIDTH 16
    #define MIN_INPUT_OBJECT_HEIGHT 16
    
    #define CHECK_NPP_STATUS(npp_status,error_str) do { \ if ((npp_status) != NPP_SUCCESS) { \ g_print ("Error: %s in %s at line %d: NPP Error %d\n", \ error_str, __FILE__, __LINE__, npp_status); \ goto error; \ } \ } while (0)
    
    #define CHECK_CUDA_STATUS(cuda_status,error_str) do { \ if ((cuda_status) != cudaSuccess) { \ g_print ("Error: %s in %s at line %d (%s)\n", \ error_str, __FILE__, __LINE__, cudaGetErrorName(cuda_status)); \ goto error; \ } \ } while (0)
    
    /* By default NVIDIA Hardware allocated memory flows through the pipeline. We * will be processing on this type of memory only. */
    #define GST_CAPS_FEATURE_MEMORY_NVMM "memory:NVMM"
    static GstStaticPadTemplate gst_dsexample_sink_template =
    GST_STATIC_PAD_TEMPLATE ("sink",
        GST_PAD_SINK,
        GST_PAD_ALWAYS,
        GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
            (GST_CAPS_FEATURE_MEMORY_NVMM,
                "{ NV12, RGBA, I420 }")));
    
    static GstStaticPadTemplate gst_dsexample_src_template =
    GST_STATIC_PAD_TEMPLATE ("src",
        GST_PAD_SRC,
        GST_PAD_ALWAYS,
        GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
            (GST_CAPS_FEATURE_MEMORY_NVMM,
                "{ NV12, RGBA, I420 }")));
    
    /* Define our element type. Standard GObject/GStreamer boilerplate stuff */
    #define gst_dsexample_parent_class parent_class
    G_DEFINE_TYPE (GstDsExample, gst_dsexample, GST_TYPE_BASE_TRANSFORM);
    
    static void gst_dsexample_set_property (GObject * object, guint prop_id,
        const GValue * value, GParamSpec * pspec);
    static void gst_dsexample_get_property (GObject * object, guint prop_id,
        GValue * value, GParamSpec * pspec);
    
    static gboolean gst_dsexample_set_caps (GstBaseTransform * btrans,
        GstCaps * incaps, GstCaps * outcaps);
    static gboolean gst_dsexample_start (GstBaseTransform * btrans);
    static gboolean gst_dsexample_stop (GstBaseTransform * btrans);
    
    static GstFlowReturn gst_dsexample_transform_ip (GstBaseTransform *
        btrans, GstBuffer * inbuf);
    
    static void
    attach_metadata_full_frame (GstDsExample * dsexample, NvDsFrameMeta *frame_meta,
        gdouble scale_ratio, DsExampleOutput * output, guint batch_id);
    static void attach_metadata_object (GstDsExample * dsexample,
        NvDsObjectMeta * obj_meta, DsExampleOutput * output);
    
    
    
    
    
    void InitMat(Mat& m, float* num)
    { 
    	for (int i = 0; i<m.rows; i++)
    	for (int j = 0; j<m.cols; j++)
    		m.at<float>(i, j) = *(num + i * m.rows + j);
    }
    
    /******************************************************************************* Function: jibianjiaozheng Description: 该函数实现畸变矫正 Input: 原图 Output: 畸变矫正后的图片 Return: 0: Successful ohters: Failed *******************************************************************************/
    int jibianjiaozheng(Mat src_picture, Mat & dst_picture)
    { 
    	int OK = 0;
    	int i = 1000;
    	int n = 1;
    	Mat edges;
    	Mat R = Mat::eye(3, 3, CV_32F);
    	
    	if (src_picture.data == NULL)
    	{ 
    		printf("param error,input Image is empty\n");
    		return -1;
    	}
    
    	Size image_size;  /* 图像的尺寸 */
    					  //获取图像大小
    	image_size.width = 1920;
    	image_size.height = 1080;
    
    	//cameraMatrix为 "相机内参数矩阵：" << endl;
    	Mat mapx = Mat(image_size, CV_32FC1);
    	Mat mapy = Mat(image_size, CV_32FC1);
    
    	//参数矩阵
    	float neican_data[] = {  9558.649257742036, 0, 959.3165310990756, 0, 9435.752651759443, 532.7507141910969, 0, 0, 1 };
    	Mat cameraMatrix(3, 3, CV_32FC1);
    	InitMat(cameraMatrix, neican_data);
    
    	//cout << "cameraMatrix= " << endl << " " << cameraMatrix << endl << endl;
    	//测得的畸变系数
    	float jibian_data[] = {  -6.956561513881647, -68.83902522804168, -0.004834538444671919, 0.01471273691928269, -0.4916103704308509 };
    	Mat distCoeffs(1, 5, CV_32FC1); /* 摄像机的5个畸变系数：k1,k2,p1,p2,k3 */
    	InitMat(distCoeffs, jibian_data);
    	//cout << "distCoeffs= " << endl << " " << distCoeffs << endl << endl;
    
    
    	i = 0;
    	//namedWindow("【原始图】", 0);//参数为零，则可以自由拖动
    	//imshow("【原始图】", src_picture);
    	/********相机矫正*******************************************************************************/
    
    	initUndistortRectifyMap(cameraMatrix, distCoeffs, R, cameraMatrix, image_size, CV_32FC1, mapx, mapy);
    
    
    	Mat imageSource = src_picture; //读取畸变图片
    	Mat newimage = imageSource.clone(); //校正后输出图片
    
    	remap(imageSource, newimage, mapx, mapy, INTER_LINEAR);
    
    	//namedWindow("畸变校正后的图片", 0);//参数为零，则可以自由拖动
    	//imshow("畸变校正后的图片", newimage);
    
    	
    	dst_picture= newimage+1;
    	return OK;
    }
    
    
    
    
    
    /* Install properties, set sink and src pad capabilities, override the required * functions of the base class, These are common to all instances of the * element. */
    static void
    gst_dsexample_class_init (GstDsExampleClass * klass)
    { 
      GObjectClass *gobject_class;
      GstElementClass *gstelement_class;
      GstBaseTransformClass *gstbasetransform_class;
    
      /* Indicates we want to use DS buf api */
      g_setenv ("DS_NEW_BUFAPI", "1", TRUE);
    
      gobject_class = (GObjectClass *) klass;
      gstelement_class = (GstElementClass *) klass;
      gstbasetransform_class = (GstBaseTransformClass *) klass;
    
      /* Overide base class functions */
      gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_dsexample_set_property);
      gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_dsexample_get_property);
    
      gstbasetransform_class->set_caps = GST_DEBUG_FUNCPTR (gst_dsexample_set_caps);
      gstbasetransform_class->start = GST_DEBUG_FUNCPTR (gst_dsexample_start);
      gstbasetransform_class->stop = GST_DEBUG_FUNCPTR (gst_dsexample_stop);
    
      gstbasetransform_class->transform_ip =
          GST_DEBUG_FUNCPTR (gst_dsexample_transform_ip);
    
      /* Install properties */
      g_object_class_install_property (gobject_class, PROP_UNIQUE_ID,
          g_param_spec_uint ("unique-id",
              "Unique ID",
              "Unique ID for the element. Can be used to identify output of the"
              " element", 0, G_MAXUINT, DEFAULT_UNIQUE_ID, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESSING_WIDTH,
          g_param_spec_int ("processing-width",
              "Processing Width",
              "Width of the input buffer to algorithm",
              1, G_MAXINT, DEFAULT_PROCESSING_WIDTH, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESSING_HEIGHT,
          g_param_spec_int ("processing-height",
              "Processing Height",
              "Height of the input buffer to algorithm",
              1, G_MAXINT, DEFAULT_PROCESSING_HEIGHT, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESS_FULL_FRAME,
          g_param_spec_boolean ("full-frame",
              "Full frame",
              "Enable to process full frame or disable to process objects detected"
              "by primary detector", DEFAULT_PROCESS_FULL_FRAME, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_BLUR_OBJECTS,
          g_param_spec_boolean ("blur-objects",
              "Blur Objects",
              "Enable to blur the objects detected in full-frame=0 mode"
              "by primary detector", DEFAULT_BLUR_OBJECTS, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_GPU_DEVICE_ID,
          g_param_spec_uint ("gpu-id",
              "Set GPU Device ID",
              "Set GPU Device ID", 0,
              G_MAXUINT, 0,
              GParamFlags
              (G_PARAM_READWRITE |
                  G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY)));
      /* Set sink and src pad capabilities */
      gst_element_class_add_pad_template (gstelement_class,
          gst_static_pad_template_get (&gst_dsexample_src_template));
      gst_element_class_add_pad_template (gstelement_class,
          gst_static_pad_template_get (&gst_dsexample_sink_template));
    
      /* Set metadata describing the element */
      gst_element_class_set_details_simple (gstelement_class,
          "DsExample plugin",
          "DsExample Plugin",
          "Process a 3rdparty example algorithm on objects / full frame",
          "NVIDIA Corporation. Post on Deepstream for Tesla forum for any queries "
          "@ https://devtalk.nvidia.com/default/board/209/");
    }
    
    static void
    gst_dsexample_init (GstDsExample * dsexample)
    { 
      GstBaseTransform *btrans = GST_BASE_TRANSFORM (dsexample);
    
      /* We will not be generating a new buffer. Just adding / updating * metadata. */
      gst_base_transform_set_in_place (GST_BASE_TRANSFORM (btrans), TRUE);
      /* We do not want to change the input caps. Set to passthrough. transform_ip * is still called. */
      gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (btrans), TRUE);
    
      /* Initialize all property variables to default values */
      dsexample->unique_id = DEFAULT_UNIQUE_ID;
      dsexample->processing_width = DEFAULT_PROCESSING_WIDTH;
      dsexample->processing_height = DEFAULT_PROCESSING_HEIGHT;
      dsexample->process_full_frame = DEFAULT_PROCESS_FULL_FRAME;
      dsexample->blur_objects = DEFAULT_BLUR_OBJECTS;
      dsexample->gpu_id = DEFAULT_GPU_ID;
      /* This quark is required to identify NvDsMeta when iterating through * the buffer metadatas */
      if (!_dsmeta_quark)
        _dsmeta_quark = g_quark_from_static_string (NVDS_META_STRING);
    }
    
    /* Function called when a property of the element is set. Standard boilerplate. */
    static void
    gst_dsexample_set_property (GObject * object, guint prop_id,
        const GValue * value, GParamSpec * pspec)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (object);
      switch (prop_id) { 
        case PROP_UNIQUE_ID:
          dsexample->unique_id = g_value_get_uint (value);
          break;
        case PROP_PROCESSING_WIDTH:
          dsexample->processing_width = g_value_get_int (value);
          break;
        case PROP_PROCESSING_HEIGHT:
          dsexample->processing_height = g_value_get_int (value);
          break;
        case PROP_PROCESS_FULL_FRAME:
          dsexample->process_full_frame = g_value_get_boolean (value);
          break;
        case PROP_BLUR_OBJECTS:
          dsexample->blur_objects = g_value_get_boolean (value);
          break;
        case PROP_GPU_DEVICE_ID:
          dsexample->gpu_id = g_value_get_uint (value);
          break;
        default:
          G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
          break;
      }
    }
    
    /* Function called when a property of the element is requested. Standard * boilerplate. */
    static void
    gst_dsexample_get_property (GObject * object, guint prop_id,
        GValue * value, GParamSpec * pspec)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (object);
    
      switch (prop_id) { 
        case PROP_UNIQUE_ID:
          g_value_set_uint (value, dsexample->unique_id);
          break;
        case PROP_PROCESSING_WIDTH:
          g_value_set_int (value, dsexample->processing_width);
          break;
        case PROP_PROCESSING_HEIGHT:
          g_value_set_int (value, dsexample->processing_height);
          break;
        case PROP_PROCESS_FULL_FRAME:
          g_value_set_boolean (value, dsexample->process_full_frame);
          break;
        case PROP_BLUR_OBJECTS:
          g_value_set_boolean (value, dsexample->blur_objects);
          break;
        case PROP_GPU_DEVICE_ID:
          g_value_set_uint (value, dsexample->gpu_id);
          break;
        default:
          G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
          break;
      }
    }
    
    /** * Initialize all resources and start the output thread */
    static gboolean
    gst_dsexample_start (GstBaseTransform * btrans)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      NvBufSurfaceCreateParams create_params;
      DsExampleInitParams init_params =
          {  dsexample->processing_width, dsexample->processing_height,
        dsexample->process_full_frame
      };
    
      GstQuery *queryparams = NULL;
      guint batch_size = 1;
    
      /* Algorithm specific initializations and resource allocation. */
      dsexample->dsexamplelib_ctx = DsExampleCtxInit (&init_params);
    
      GST_DEBUG_OBJECT (dsexample, "ctx lib %p \n", dsexample->dsexamplelib_ctx);
    
      CHECK_CUDA_STATUS (cudaSetDevice (dsexample->gpu_id),
          "Unable to set cuda device");
    
      dsexample->batch_size = 1;
      queryparams = gst_nvquery_batch_size_new ();
      if (gst_pad_peer_query (GST_BASE_TRANSFORM_SINK_PAD (btrans), queryparams)
          || gst_pad_peer_query (GST_BASE_TRANSFORM_SRC_PAD (btrans), queryparams)) { 
        if (gst_nvquery_batch_size_parse (queryparams, &batch_size)) { 
          dsexample->batch_size = batch_size;
        }
      }
      GST_DEBUG_OBJECT (dsexample, "Setting batch-size %d \n",
          dsexample->batch_size);
      gst_query_unref (queryparams);
    
      if (dsexample->process_full_frame && dsexample->blur_objects) { 
        GST_ERROR ("Error: does not support blurring while processing full frame");
        goto error;
      }
    
      CHECK_CUDA_STATUS (cudaStreamCreate (&dsexample->cuda_stream),
          "Could not create cuda stream");
    
      if (dsexample->inter_buf)
        NvBufSurfaceDestroy (dsexample->inter_buf);
      dsexample->inter_buf = NULL;
    
      /* An intermediate buffer for NV12/RGBA to BGR conversion will be * required. Can be skipped if custom algorithm can work directly on NV12/RGBA. */
      create_params.gpuId  = dsexample->gpu_id;
      create_params.width  = dsexample->processing_width;
      create_params.height = dsexample->processing_height;
      create_params.size = 0;
      create_params.colorFormat = NVBUF_COLOR_FORMAT_RGBA;
      create_params.layout = NVBUF_LAYOUT_PITCH;
    #ifdef __aarch64__
      create_params.memType = NVBUF_MEM_DEFAULT;
    #else
      create_params.memType = NVBUF_MEM_CUDA_UNIFIED;
    #endif
    
      if (NvBufSurfaceCreate (&dsexample->inter_buf, 1,
              &create_params) != 0) { 
        GST_ERROR ("Error: Could not allocate internal buffer for dsexample");
        goto error;
      }
    
      /* Create host memory for storing converted/scaled interleaved RGB data */
      CHECK_CUDA_STATUS (cudaMallocHost (&dsexample->host_rgb_buf,
              dsexample->processing_width * dsexample->processing_height *
              RGB_BYTES_PER_PIXEL), "Could not allocate cuda host buffer");
    
      GST_DEBUG_OBJECT (dsexample, "allocated cuda buffer %p \n",
          dsexample->host_rgb_buf);
    
      /* CV Mat containing interleaved RGB data. This call does not allocate memory. * It uses host_rgb_buf as data. */
      dsexample->cvmat =
          new cv::Mat (dsexample->processing_height, dsexample->processing_width,
          CV_8UC3, dsexample->host_rgb_buf,
          dsexample->processing_width * RGB_BYTES_PER_PIXEL);
    
      if (!dsexample->cvmat)
        goto error;
    
      GST_DEBUG_OBJECT (dsexample, "created CV Mat\n");
    
      return TRUE;
    error:
      if (dsexample->host_rgb_buf) { 
        cudaFreeHost (dsexample->host_rgb_buf);
        dsexample->host_rgb_buf = NULL;
      }
    
      if (dsexample->cuda_stream) { 
        cudaStreamDestroy (dsexample->cuda_stream);
        dsexample->cuda_stream = NULL;
      }
      if (dsexample->dsexamplelib_ctx)
        DsExampleCtxDeinit (dsexample->dsexamplelib_ctx);
      return FALSE;
    }
    
    /** * Stop the output thread and free up all the resources */
    static gboolean
    gst_dsexample_stop (GstBaseTransform * btrans)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
    
      if (dsexample->inter_buf)
        NvBufSurfaceDestroy(dsexample->inter_buf);
      dsexample->inter_buf = NULL;
    
      if (dsexample->cuda_stream)
        cudaStreamDestroy (dsexample->cuda_stream);
      dsexample->cuda_stream = NULL;
    
      delete dsexample->cvmat;
      dsexample->cvmat = NULL;
    
      if (dsexample->host_rgb_buf) { 
        cudaFreeHost (dsexample->host_rgb_buf);
        dsexample->host_rgb_buf = NULL;
      }
    
      GST_DEBUG_OBJECT (dsexample, "deleted CV Mat \n");
    
      /* Deinit the algorithm library */
      DsExampleCtxDeinit (dsexample->dsexamplelib_ctx);
      dsexample->dsexamplelib_ctx = NULL;
    
      GST_DEBUG_OBJECT (dsexample, "ctx lib released \n");
    
      return TRUE;
    }
    
    /** * Called when source / sink pad capabilities have been negotiated. */
    static gboolean
    gst_dsexample_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
        GstCaps * outcaps)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      /* Save the input video information, since this will be required later. */
      gst_video_info_from_caps (&dsexample->video_info, incaps);
    
      if (dsexample->blur_objects && !dsexample->process_full_frame) { 
        /* requires RGBA format for blurring the objects in opencv */
         if (dsexample->video_info.finfo->format != GST_VIDEO_FORMAT_RGBA) { 
          GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
              ("input format should be RGBA when using blur-objects property"), (NULL));
          goto error;
          }
      }
    
      return TRUE;
    
    error:
      return FALSE;
    }
    
    /** * Scale the entire frame to the processing resolution maintaining aspect ratio. * Or crop and scale objects to the processing resolution maintaining the aspect * ratio. Remove the padding required by hardware and convert from RGBA to RGB * using openCV. These steps can be skipped if the algorithm can work with * padded data and/or can work with RGBA. */
    static GstFlowReturn
    get_converted_mat (GstDsExample * dsexample, NvBufSurface *input_buf, gint idx,
        NvOSD_RectParams * crop_rect_params, gdouble & ratio, gint input_width,
        gint input_height)
    { 
      NvBufSurfTransform_Error err;
      NvBufSurfTransformConfigParams transform_config_params;
      NvBufSurfTransformParams transform_params;
      NvBufSurfTransformRect src_rect;
      NvBufSurfTransformRect dst_rect;
      NvBufSurface ip_surf;
      cv::Mat in_mat;
      ip_surf = *input_buf;
    
      ip_surf.numFilled = ip_surf.batchSize = 1;
      ip_surf.surfaceList = &(input_buf->surfaceList[idx]);
    
      gint src_left = GST_ROUND_UP_2((unsigned int)crop_rect_params->left);
      gint src_top = GST_ROUND_UP_2((unsigned int)crop_rect_params->top);
      gint src_width = GST_ROUND_DOWN_2((unsigned int)crop_rect_params->width);
      gint src_height = GST_ROUND_DOWN_2((unsigned int)crop_rect_params->height);
    
      /* Maintain aspect ratio */
      double hdest = dsexample->processing_width * src_height / (double) src_width;
      double wdest = dsexample->processing_height * src_width / (double) src_height;
      guint dest_width, dest_height;
    
      if (hdest <= dsexample->processing_height) { 
        dest_width = dsexample->processing_width;
        dest_height = hdest;
      } else { 
        dest_width = wdest;
        dest_height = dsexample->processing_height;
      }
    
      /* Configure transform session parameters for the transformation */
      transform_config_params.compute_mode = NvBufSurfTransformCompute_Default;
      transform_config_params.gpu_id = dsexample->gpu_id;
      transform_config_params.cuda_stream = dsexample->cuda_stream;
    
      /* Set the transform session parameters for the conversions executed in this * thread. */
      err = NvBufSurfTransformSetSessionParams (&transform_config_params);
      if (err != NvBufSurfTransformError_Success) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvBufSurfTransformSetSessionParams failed with error %d", err), (NULL));
        goto error;
      }
    
      /* Calculate scaling ratio while maintaining aspect ratio */
      ratio = MIN (1.0 * dest_width/ src_width, 1.0 * dest_height / src_height);
    
      if ((crop_rect_params->width == 0) || (crop_rect_params->height == 0)) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("%s:crop_rect_params dimensions are zero",__func__), (NULL));
        goto error;
      }
    
    #ifdef __aarch64__
      if (ratio <= 1.0 / 16 || ratio >= 16.0) { 
        /* Currently cannot scale by ratio > 16 or < 1/16 for Jetson */
        goto error;
      }
    #endif
      /* Set the transform ROIs for source and destination */
      src_rect = { (guint)src_top, (guint)src_left, (guint)src_width, (guint)src_height};
      dst_rect = { 0, 0, (guint)dest_width, (guint)dest_height};
    
      /* Set the transform parameters */
      transform_params.src_rect = &src_rect;
      transform_params.dst_rect = &dst_rect;
      transform_params.transform_flag =
        NVBUFSURF_TRANSFORM_FILTER | NVBUFSURF_TRANSFORM_CROP_SRC |
          NVBUFSURF_TRANSFORM_CROP_DST;
      transform_params.transform_filter = NvBufSurfTransformInter_Default;
    
      /* Memset the memory */
      NvBufSurfaceMemSet (dsexample->inter_buf, 0, 0, 0);
    
      GST_DEBUG_OBJECT (dsexample, "Scaling and converting input buffer\n");
    
      /* Transformation scaling+format conversion if any. */
      err = NvBufSurfTransform (&ip_surf, dsexample->inter_buf, &transform_params);
      if (err != NvBufSurfTransformError_Success) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvBufSurfTransform failed with error %d while converting buffer", err),
            (NULL));
        goto error;
      }
      /* Map the buffer so that it can be accessed by CPU */
      if (NvBufSurfaceMap (dsexample->inter_buf, 0, 0, NVBUF_MAP_READ) != 0){ 
        goto error;
      }
    
      /* Cache the mapped data for CPU access */
      NvBufSurfaceSyncForCpu (dsexample->inter_buf, 0, 0);
    
      /* Use openCV to remove padding and convert RGBA to BGR. Can be skipped if * algorithm can handle padded RGBA data. */
      in_mat =
          cv::Mat (dsexample->processing_height, dsexample->processing_width,
          CV_8UC4, dsexample->inter_buf->surfaceList[0].mappedAddr.addr[0],
          dsexample->inter_buf->surfaceList[0].pitch);
    
    #if (CV_MAJOR_VERSION >= 4)
      cv::cvtColor (in_mat, *dsexample->cvmat, cv::COLOR_RGBA2BGR);
    #else
      cv::cvtColor (in_mat, *dsexample->cvmat, CV_RGBA2BGR);
    #endif
    
      if (NvBufSurfaceUnMap (dsexample->inter_buf, 0, 0)){ 
        goto error;
      }
    
    #ifdef __aarch64__
      /* To use the converted buffer in CUDA, create an EGLImage and then use * CUDA-EGL interop APIs */
      if (USE_EGLIMAGE) { 
        if (NvBufSurfaceMapEglImage (dsexample->inter_buf, 0) !=0 ) { 
          goto error;
        }
    
        /* dsexample->inter_buf->surfaceList[0].mappedAddr.eglImage * Use interop APIs cuGraphicsEGLRegisterImage and * cuGraphicsResourceGetMappedEglFrame to access the buffer in CUDA */
    
        /* Destroy the EGLImage */
        NvBufSurfaceUnMapEglImage (dsexample->inter_buf, 0);
      }
    #endif
    
      /* We will first convert only the Region of Interest (the entire frame or the * object bounding box) to RGB and then scale the converted RGB frame to * processing resolution. */
      return GST_FLOW_OK;
    
    error:
      return GST_FLOW_ERROR;
    }
    
    /* * Blur the detected objects when processing in object mode (full-frame=0) */
    static GstFlowReturn
    blur_objects (GstDsExample * dsexample, gint idx,
        NvOSD_RectParams * crop_rect_params, cv::Mat in_mat)
    { 
      int hrst=1;
      cv::Rect crop_rect;
      
      if ((crop_rect_params->width == 0) || (crop_rect_params->height == 0)) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("%s:crop_rect_params dimensions are zero",__func__), (NULL));
        return GST_FLOW_ERROR;
      }
    
    /* rectangle for cropped objects */
      crop_rect = cv::Rect (crop_rect_params->left, crop_rect_params->top,
      crop_rect_params->width, crop_rect_params->height);
    
    /* apply gaussian blur to the detected objects */
      //GaussianBlur(in_mat(crop_rect), in_mat(crop_rect), cv::Size(15,15), 4);
      hrst = jibianjiaozheng(in_mat, in_mat);
      if (hrst != 0)
      { 
    	printf("畸变矫正失败\n");
      }
      else
      { 
    	//printf("畸变矫正成功\n");
      }
      return GST_FLOW_OK;
    }
    
    /** * Called when element recieves an input buffer from upstream element. */
    static GstFlowReturn
    gst_dsexample_transform_ip (GstBaseTransform * btrans, GstBuffer * inbuf)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      GstMapInfo in_map_info;
      GstFlowReturn flow_ret = GST_FLOW_ERROR;
      gdouble scale_ratio = 1.0;
      DsExampleOutput *output;
    
      NvBufSurface *surface = NULL;
      NvDsBatchMeta *batch_meta = NULL;
      NvDsFrameMeta *frame_meta = NULL;
      NvDsMetaList * l_frame = NULL;
      guint i = 0;
    
      dsexample->frame_num++;
      CHECK_CUDA_STATUS (cudaSetDevice (dsexample->gpu_id),
          "Unable to set cuda device");
    
      memset (&in_map_info, 0, sizeof (in_map_info));
      if (!gst_buffer_map (inbuf, &in_map_info, GST_MAP_READ)) { 
        g_print ("Error: Failed to map gst buffer\n");
        goto error;
      }
    
      nvds_set_input_system_timestamp (inbuf, GST_ELEMENT_NAME (dsexample));
      surface = (NvBufSurface *) in_map_info.data;
      GST_DEBUG_OBJECT (dsexample,
          "Processing Frame %" G_GUINT64_FORMAT " Surface %p\n",
          dsexample->frame_num, surface);
    
      if (CHECK_NVDS_MEMORY_AND_GPUID (dsexample, surface))
        goto error;
    
      batch_meta = gst_buffer_get_nvds_batch_meta (inbuf);
      if (batch_meta == nullptr) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvDsBatchMeta not found for input buffer."), (NULL));
        return GST_FLOW_ERROR;
      }
    
      if (dsexample->process_full_frame) { 
        for (l_frame = batch_meta->frame_meta_list; l_frame != NULL;
          l_frame = l_frame->next)
        { 
          frame_meta = (NvDsFrameMeta *) (l_frame->data);
          NvOSD_RectParams rect_params;
    
          /* Scale the entire frame to processing resolution */
          rect_params.left = 0;
          rect_params.top = 0;
          rect_params.width = dsexample->video_info.width;
          rect_params.height = dsexample->video_info.height;
    
          /* Scale and convert the frame */
          if (get_converted_mat (dsexample, surface, i, &rect_params,
                scale_ratio, dsexample->video_info.width,
                dsexample->video_info.height) != GST_FLOW_OK) { 
            goto error;
          }
    
          /* Process to get the output */
          output =
              DsExampleProcess (dsexample->dsexamplelib_ctx,
              dsexample->cvmat->data);
          /* Attach the metadata for the full frame */
          attach_metadata_full_frame (dsexample, frame_meta, scale_ratio, output, i);
          i++;
          free (output);
        }	
    
    
      } else { 
        /* Using object crops as input to the algorithm. The objects are detected by * the primary detector */
        NvDsMetaList * l_obj = NULL;
        NvDsObjectMeta *obj_meta = NULL;
    
    #ifndef __aarch64__
        if (dsexample->blur_objects) { 
          if (surface->memType != NVBUF_MEM_CUDA_UNIFIED){ 
            GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                ("%s:need NVBUF_MEM_CUDA_UNIFIED memory for opencv blurring",__func__), (NULL));
            return GST_FLOW_ERROR;
          }
        }
    #endif
    
        for (l_frame = batch_meta->frame_meta_list; l_frame != NULL;
          l_frame = l_frame->next)
        { 
          frame_meta = (NvDsFrameMeta *) (l_frame->data);
          cv::Mat in_mat;
    
          if (dsexample->blur_objects) { 
            /* Map the buffer so that it can be accessed by CPU */
            if (surface->surfaceList[frame_meta->batch_id].mappedAddr.addr[0] == NULL){ 
              if (NvBufSurfaceMap (surface, frame_meta->batch_id, 0, NVBUF_MAP_READ_WRITE) != 0){ 
                GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                    ("%s:buffer map to be accessed by CPU failed", __func__), (NULL));
                return GST_FLOW_ERROR;
              }
            }
    
            /* Cache the mapped data for CPU access */
            NvBufSurfaceSyncForCpu (surface, frame_meta->batch_id, 0);
    
            in_mat =
                cv::Mat (surface->surfaceList[frame_meta->batch_id].planeParams.height[0],
                surface->surfaceList[frame_meta->batch_id].planeParams.width[0], CV_8UC4,
                surface->surfaceList[frame_meta->batch_id].mappedAddr.addr[0],
                surface->surfaceList[frame_meta->batch_id].planeParams.pitch[0]);
          }
    
          for (l_obj = frame_meta->obj_meta_list; l_obj != NULL;
              l_obj = l_obj->next)
          { 
            obj_meta = (NvDsObjectMeta *) (l_obj->data);
    
            if (dsexample->blur_objects) { 
              /* gaussian blur the detected objects using opencv */
              if (blur_objects (dsexample, frame_meta->batch_id,
                &obj_meta->rect_params, in_mat) != GST_FLOW_OK) { 
              /* Error in blurring, skip processing on object. */
                GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                ("blurring the object failed"), (NULL));
                if (NvBufSurfaceUnMap (surface, frame_meta->batch_id, 0)){ 
                  GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                    ("%s:buffer unmap to be accessed by CPU failed", __func__), (NULL));
                }
                return GST_FLOW_ERROR;
              }
              continue;
            }
    
            /* Should not process on objects smaller than MIN_INPUT_OBJECT_WIDTH x MIN_INPUT_OBJECT_HEIGHT * since it will cause hardware scaling issues. */
            if (obj_meta->rect_params.width < MIN_INPUT_OBJECT_WIDTH ||
                obj_meta->rect_params.height < MIN_INPUT_OBJECT_HEIGHT)
              continue;
    
            /* Crop and scale the object */
            if (get_converted_mat (dsexample,
                  surface, frame_meta->batch_id, &obj_meta->rect_params,
                  scale_ratio, dsexample->video_info.width,
                  dsexample->video_info.height) != GST_FLOW_OK) { 
              /* Error in conversion, skip processing on object. */
              continue;
            }
    
            /* Process the object crop to obtain label */
            output = DsExampleProcess (dsexample->dsexamplelib_ctx,
                dsexample->cvmat->data);
    
            /* Attach labels for the object */
            attach_metadata_object (dsexample, obj_meta, output);
    
            free (output);
          }
    
          if (dsexample->blur_objects) { 
          /* Cache the mapped data for device access */
            NvBufSurfaceSyncForDevice (surface, frame_meta->batch_id, 0);
    
    #ifdef DSEXAMPLE_DEBUG
            /* Use openCV to remove padding and convert RGBA to BGR. Can be skipped if * algorithm can handle padded RGBA data. */
    #if (CV_MAJOR_VERSION >= 4)
            cv::cvtColor (in_mat, *dsexample->cvmat, cv::COLOR_RGBA2BGR);
    #else
            cv::cvtColor (in_mat, *dsexample->cvmat, CV_RGBA2BGR);
    #endif
            /* used to dump the converted mat to files for debug */
            static guint cnt = 0;
            cv::imwrite("out_" + std::to_string (cnt) + ".jpeg", *dsexample->cvmat);
            cnt++;
    #endif
          }
        }
      }
      flow_ret = GST_FLOW_OK;
    
    error:
    
      nvds_set_output_system_timestamp (inbuf, GST_ELEMENT_NAME (dsexample));
      gst_buffer_unmap (inbuf, &in_map_info);
      return flow_ret;
    }
    
    /** * Attach metadata for the full frame. We will be adding a new metadata. */
    static void
    attach_metadata_full_frame (GstDsExample * dsexample, NvDsFrameMeta *frame_meta,
        gdouble scale_ratio, DsExampleOutput * output, guint batch_id)
    { 
      NvDsBatchMeta *batch_meta = frame_meta->base_meta.batch_meta;
      NvDsObjectMeta *object_meta = NULL;
      static gchar font_name[] = "Serif";
      GST_DEBUG_OBJECT (dsexample, "Attaching metadata %d\n", output->numObjects);
    
      for (gint i = 0; i < output->numObjects; i++) { 
        DsExampleObject *obj = &output->object[i];
        object_meta = nvds_acquire_obj_meta_from_pool(batch_meta);
        NvOSD_RectParams & rect_params = object_meta->rect_params;
        NvOSD_TextParams & text_params = object_meta->text_params;
    
        /* Assign bounding box coordinates */
        rect_params.left = obj->left;
        rect_params.top = obj->top;
        rect_params.width = obj->width;
        rect_params.height = obj->height;
    
        /* Semi-transparent yellow background */
        rect_params.has_bg_color = 0;
        rect_params.bg_color = (NvOSD_ColorParams) { 
        1, 1, 0, 0.4};
        /* Red border of width 6 */
        rect_params.border_width = 3;
        rect_params.border_color = (NvOSD_ColorParams) { 
        1, 0, 0, 1};
    
        /* Scale the bounding boxes proportionally based on how the object/frame was * scaled during input */
        rect_params.left /= scale_ratio;
        rect_params.top /= scale_ratio;
        rect_params.width /= scale_ratio;
        rect_params.height /= scale_ratio;
        GST_DEBUG_OBJECT (dsexample, "Attaching rect%d of batch%u"
            " left->%f top->%f width->%f"
            " height->%f label->%s\n", i, batch_id, rect_params.left,
            rect_params.top, rect_params.width, rect_params.height, obj->label);
    
        object_meta->object_id = UNTRACKED_OBJECT_ID;
        g_strlcpy (object_meta->obj_label, obj->label, MAX_LABEL_SIZE);
        /* display_text required heap allocated memory */
        text_params.display_text = g_strdup (obj->label);
        /* Display text above the left top corner of the object */
        text_params.x_offset = rect_params.left;
        text_params.y_offset = rect_params.top - 10;
        /* Set black background for the text */
        text_params.set_bg_clr = 1;
        text_params.text_bg_clr = (NvOSD_ColorParams) { 
        0, 0, 0, 1};
        /* Font face, size and color */
        text_params.font_params.font_name = font_name;
        text_params.font_params.font_size = 11;
        text_params.font_params.font_color = (NvOSD_ColorParams) { 
        1, 1, 1, 1};
    
        nvds_add_obj_meta_to_frame(frame_meta, object_meta, NULL);
        frame_meta->bInferDone = TRUE;
      }
    }
    
    /** * Only update string label in an existing object metadata. No bounding boxes. * We assume only one label per object is generated */
    static void
    attach_metadata_object (GstDsExample * dsexample, NvDsObjectMeta * obj_meta,
        DsExampleOutput * output)
    { 
      if (output->numObjects == 0)
        return;
      NvDsBatchMeta *batch_meta = obj_meta->base_meta.batch_meta;
    
      NvDsClassifierMeta *classifier_meta =
        nvds_acquire_classifier_meta_from_pool (batch_meta);
    
      classifier_meta->unique_component_id = dsexample->unique_id;
    
      NvDsLabelInfo *label_info =
        nvds_acquire_label_info_meta_from_pool (batch_meta);
      g_strlcpy (label_info->result_label, output->object[0].label, MAX_LABEL_SIZE);
      nvds_add_label_info_meta_to_classifier(classifier_meta, label_info);
      nvds_add_classifier_meta_to_object (obj_meta, classifier_meta);
    
      nvds_acquire_meta_lock (batch_meta);
      NvOSD_TextParams & text_params = obj_meta->text_params;
      NvOSD_RectParams & rect_params = obj_meta->rect_params;
    
      /* Below code to display the result */
      /* Set black background for the text * display_text required heap allocated memory */
      if (text_params.display_text) { 
        gchar *conc_string = g_strconcat (text_params.display_text, " ",
            output->object[0].label, NULL);
        g_free (text_params.display_text);
        text_params.display_text = conc_string;
      } else { 
        /* Display text above the left top corner of the object */
        text_params.x_offset = rect_params.left;
        text_params.y_offset = rect_params.top - 10;
        text_params.display_text = g_strdup (output->object[0].label);
        /* Font face, size and color */
        text_params.font_params.font_name = (char *)"Serif";
        text_params.font_params.font_size = 11;
        text_params.font_params.font_color = (NvOSD_ColorParams) { 
        1, 1, 1, 1};
        /* Set black background for the text */
        text_params.set_bg_clr = 1;
        text_params.text_bg_clr = (NvOSD_ColorParams) { 
        0, 0, 0, 1};
      }
      nvds_release_meta_lock (batch_meta);
    }
    
    /** * Boiler plate for registering a plugin and an element. */
    static gboolean
    dsexample_plugin_init (GstPlugin * plugin)
    { 
      GST_DEBUG_CATEGORY_INIT (gst_dsexample_debug, "dsexample", 0,
          "dsexample plugin");
    
      return gst_element_register (plugin, "dsexample", GST_RANK_PRIMARY,
          GST_TYPE_DSEXAMPLE);
    }
    
    GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
        GST_VERSION_MINOR,
        nvdsgst_dsexample,
        DESCRIPTION, dsexample_plugin_init, DS_VERSION, LICENSE, BINARY_PACKAGE, URL)

# normal #

/** * Copyright (c) 2017-2020, NVIDIA CORPORATION. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */
    
    #include <string.h>
    #include <string>
    #include <sstream>
    #include <iostream>
    #include <ostream>
    #include <fstream>
    #include "gstdsexample.h"
    #include <sys/time.h>
    GST_DEBUG_CATEGORY_STATIC (gst_dsexample_debug);
    #define GST_CAT_DEFAULT gst_dsexample_debug
    #define USE_EGLIMAGE 1
    /* enable to write transformed cvmat to files */
    /* #define DSEXAMPLE_DEBUG */
    static GQuark _dsmeta_quark = 0;
    
    /* Enum to identify properties */
    enum
    { 
      PROP_0,
      PROP_UNIQUE_ID,
      PROP_PROCESSING_WIDTH,
      PROP_PROCESSING_HEIGHT,
      PROP_PROCESS_FULL_FRAME,
      PROP_BLUR_OBJECTS,
      PROP_GPU_DEVICE_ID
    };
    
    #define CHECK_NVDS_MEMORY_AND_GPUID(object, surface) \ ({ int _errtype=0;\ do { \ if ((surface->memType == NVBUF_MEM_DEFAULT || surface->memType == NVBUF_MEM_CUDA_DEVICE) && \ (surface->gpuId != object->gpu_id)) { \ GST_ELEMENT_ERROR (object, RESOURCE, FAILED, \ ("Input surface gpu-id doesnt match with configured gpu-id for element," \ " please allocate input using unified memory, or use same gpu-ids"),\ ("surface-gpu-id=%d,%s-gpu-id=%d",surface->gpuId,GST_ELEMENT_NAME(object),\ object->gpu_id)); \ _errtype = 1;\ } \ } while(0); \ _errtype; \ })
    
    
    /* Default values for properties */
    #define DEFAULT_UNIQUE_ID 15
    #define DEFAULT_PROCESSING_WIDTH 640
    #define DEFAULT_PROCESSING_HEIGHT 480
    #define DEFAULT_PROCESS_FULL_FRAME TRUE
    #define DEFAULT_BLUR_OBJECTS FALSE
    #define DEFAULT_GPU_ID 0
    
    #define RGB_BYTES_PER_PIXEL 3
    #define RGBA_BYTES_PER_PIXEL 4
    #define Y_BYTES_PER_PIXEL 1
    #define UV_BYTES_PER_PIXEL 2
    
    #define MIN_INPUT_OBJECT_WIDTH 16
    #define MIN_INPUT_OBJECT_HEIGHT 16
    
    #define CHECK_NPP_STATUS(npp_status,error_str) do { \ if ((npp_status) != NPP_SUCCESS) { \ g_print ("Error: %s in %s at line %d: NPP Error %d\n", \ error_str, __FILE__, __LINE__, npp_status); \ goto error; \ } \ } while (0)
    
    #define CHECK_CUDA_STATUS(cuda_status,error_str) do { \ if ((cuda_status) != cudaSuccess) { \ g_print ("Error: %s in %s at line %d (%s)\n", \ error_str, __FILE__, __LINE__, cudaGetErrorName(cuda_status)); \ goto error; \ } \ } while (0)
    
    /* By default NVIDIA Hardware allocated memory flows through the pipeline. We * will be processing on this type of memory only. */
    #define GST_CAPS_FEATURE_MEMORY_NVMM "memory:NVMM"
    static GstStaticPadTemplate gst_dsexample_sink_template =
    GST_STATIC_PAD_TEMPLATE ("sink",
        GST_PAD_SINK,
        GST_PAD_ALWAYS,
        GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
            (GST_CAPS_FEATURE_MEMORY_NVMM,
                "{ NV12, RGBA, I420 }")));
    
    static GstStaticPadTemplate gst_dsexample_src_template =
    GST_STATIC_PAD_TEMPLATE ("src",
        GST_PAD_SRC,
        GST_PAD_ALWAYS,
        GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
            (GST_CAPS_FEATURE_MEMORY_NVMM,
                "{ NV12, RGBA, I420 }")));
    
    /* Define our element type. Standard GObject/GStreamer boilerplate stuff */
    #define gst_dsexample_parent_class parent_class
    G_DEFINE_TYPE (GstDsExample, gst_dsexample, GST_TYPE_BASE_TRANSFORM);
    
    static void gst_dsexample_set_property (GObject * object, guint prop_id,
        const GValue * value, GParamSpec * pspec);
    static void gst_dsexample_get_property (GObject * object, guint prop_id,
        GValue * value, GParamSpec * pspec);
    
    static gboolean gst_dsexample_set_caps (GstBaseTransform * btrans,
        GstCaps * incaps, GstCaps * outcaps);
    static gboolean gst_dsexample_start (GstBaseTransform * btrans);
    static gboolean gst_dsexample_stop (GstBaseTransform * btrans);
    
    static GstFlowReturn gst_dsexample_transform_ip (GstBaseTransform *
        btrans, GstBuffer * inbuf);
    
    static void
    attach_metadata_full_frame (GstDsExample * dsexample, NvDsFrameMeta *frame_meta,
        gdouble scale_ratio, DsExampleOutput * output, guint batch_id);
    static void attach_metadata_object (GstDsExample * dsexample,
        NvDsObjectMeta * obj_meta, DsExampleOutput * output);
    
    /* Install properties, set sink and src pad capabilities, override the required * functions of the base class, These are common to all instances of the * element. */
    static void
    gst_dsexample_class_init (GstDsExampleClass * klass)
    { 
      GObjectClass *gobject_class;
      GstElementClass *gstelement_class;
      GstBaseTransformClass *gstbasetransform_class;
    
      /* Indicates we want to use DS buf api */
      g_setenv ("DS_NEW_BUFAPI", "1", TRUE);
    
      gobject_class = (GObjectClass *) klass;
      gstelement_class = (GstElementClass *) klass;
      gstbasetransform_class = (GstBaseTransformClass *) klass;
    
      /* Overide base class functions */
      gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_dsexample_set_property);
      gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_dsexample_get_property);
    
      gstbasetransform_class->set_caps = GST_DEBUG_FUNCPTR (gst_dsexample_set_caps);
      gstbasetransform_class->start = GST_DEBUG_FUNCPTR (gst_dsexample_start);
      gstbasetransform_class->stop = GST_DEBUG_FUNCPTR (gst_dsexample_stop);
    
      gstbasetransform_class->transform_ip =
          GST_DEBUG_FUNCPTR (gst_dsexample_transform_ip);
    
      /* Install properties */
      g_object_class_install_property (gobject_class, PROP_UNIQUE_ID,
          g_param_spec_uint ("unique-id",
              "Unique ID",
              "Unique ID for the element. Can be used to identify output of the"
              " element", 0, G_MAXUINT, DEFAULT_UNIQUE_ID, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESSING_WIDTH,
          g_param_spec_int ("processing-width",
              "Processing Width",
              "Width of the input buffer to algorithm",
              1, G_MAXINT, DEFAULT_PROCESSING_WIDTH, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESSING_HEIGHT,
          g_param_spec_int ("processing-height",
              "Processing Height",
              "Height of the input buffer to algorithm",
              1, G_MAXINT, DEFAULT_PROCESSING_HEIGHT, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_PROCESS_FULL_FRAME,
          g_param_spec_boolean ("full-frame",
              "Full frame",
              "Enable to process full frame or disable to process objects detected"
              "by primary detector", DEFAULT_PROCESS_FULL_FRAME, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_BLUR_OBJECTS,
          g_param_spec_boolean ("blur-objects",
              "Blur Objects",
              "Enable to blur the objects detected in full-frame=0 mode"
              "by primary detector", DEFAULT_BLUR_OBJECTS, (GParamFlags)
              (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
    
      g_object_class_install_property (gobject_class, PROP_GPU_DEVICE_ID,
          g_param_spec_uint ("gpu-id",
              "Set GPU Device ID",
              "Set GPU Device ID", 0,
              G_MAXUINT, 0,
              GParamFlags
              (G_PARAM_READWRITE |
                  G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY)));
      /* Set sink and src pad capabilities */
      gst_element_class_add_pad_template (gstelement_class,
          gst_static_pad_template_get (&gst_dsexample_src_template));
      gst_element_class_add_pad_template (gstelement_class,
          gst_static_pad_template_get (&gst_dsexample_sink_template));
    
      /* Set metadata describing the element */
      gst_element_class_set_details_simple (gstelement_class,
          "DsExample plugin",
          "DsExample Plugin",
          "Process a 3rdparty example algorithm on objects / full frame",
          "NVIDIA Corporation. Post on Deepstream for Tesla forum for any queries "
          "@ https://devtalk.nvidia.com/default/board/209/");
    }
    
    static void
    gst_dsexample_init (GstDsExample * dsexample)
    { 
      GstBaseTransform *btrans = GST_BASE_TRANSFORM (dsexample);
    
      /* We will not be generating a new buffer. Just adding / updating * metadata. */
      gst_base_transform_set_in_place (GST_BASE_TRANSFORM (btrans), TRUE);
      /* We do not want to change the input caps. Set to passthrough. transform_ip * is still called. */
      gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (btrans), TRUE);
    
      /* Initialize all property variables to default values */
      dsexample->unique_id = DEFAULT_UNIQUE_ID;
      dsexample->processing_width = DEFAULT_PROCESSING_WIDTH;
      dsexample->processing_height = DEFAULT_PROCESSING_HEIGHT;
      dsexample->process_full_frame = DEFAULT_PROCESS_FULL_FRAME;
      dsexample->blur_objects = DEFAULT_BLUR_OBJECTS;
      dsexample->gpu_id = DEFAULT_GPU_ID;
      /* This quark is required to identify NvDsMeta when iterating through * the buffer metadatas */
      if (!_dsmeta_quark)
        _dsmeta_quark = g_quark_from_static_string (NVDS_META_STRING);
    }
    
    /* Function called when a property of the element is set. Standard boilerplate. */
    static void
    gst_dsexample_set_property (GObject * object, guint prop_id,
        const GValue * value, GParamSpec * pspec)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (object);
      switch (prop_id) { 
        case PROP_UNIQUE_ID:
          dsexample->unique_id = g_value_get_uint (value);
          break;
        case PROP_PROCESSING_WIDTH:
          dsexample->processing_width = g_value_get_int (value);
          break;
        case PROP_PROCESSING_HEIGHT:
          dsexample->processing_height = g_value_get_int (value);
          break;
        case PROP_PROCESS_FULL_FRAME:
          dsexample->process_full_frame = g_value_get_boolean (value);
          break;
        case PROP_BLUR_OBJECTS:
          dsexample->blur_objects = g_value_get_boolean (value);
          break;
        case PROP_GPU_DEVICE_ID:
          dsexample->gpu_id = g_value_get_uint (value);
          break;
        default:
          G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
          break;
      }
    }
    
    /* Function called when a property of the element is requested. Standard * boilerplate. */
    static void
    gst_dsexample_get_property (GObject * object, guint prop_id,
        GValue * value, GParamSpec * pspec)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (object);
    
      switch (prop_id) { 
        case PROP_UNIQUE_ID:
          g_value_set_uint (value, dsexample->unique_id);
          break;
        case PROP_PROCESSING_WIDTH:
          g_value_set_int (value, dsexample->processing_width);
          break;
        case PROP_PROCESSING_HEIGHT:
          g_value_set_int (value, dsexample->processing_height);
          break;
        case PROP_PROCESS_FULL_FRAME:
          g_value_set_boolean (value, dsexample->process_full_frame);
          break;
        case PROP_BLUR_OBJECTS:
          g_value_set_boolean (value, dsexample->blur_objects);
          break;
        case PROP_GPU_DEVICE_ID:
          g_value_set_uint (value, dsexample->gpu_id);
          break;
        default:
          G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
          break;
      }
    }
    
    /** * Initialize all resources and start the output thread */
    static gboolean
    gst_dsexample_start (GstBaseTransform * btrans)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      NvBufSurfaceCreateParams create_params;
      DsExampleInitParams init_params =
          {  dsexample->processing_width, dsexample->processing_height,
        dsexample->process_full_frame
      };
    
      GstQuery *queryparams = NULL;
      guint batch_size = 1;
    
      /* Algorithm specific initializations and resource allocation. */
      dsexample->dsexamplelib_ctx = DsExampleCtxInit (&init_params);
    
      GST_DEBUG_OBJECT (dsexample, "ctx lib %p \n", dsexample->dsexamplelib_ctx);
    
      CHECK_CUDA_STATUS (cudaSetDevice (dsexample->gpu_id),
          "Unable to set cuda device");
    
      dsexample->batch_size = 1;
      queryparams = gst_nvquery_batch_size_new ();
      if (gst_pad_peer_query (GST_BASE_TRANSFORM_SINK_PAD (btrans), queryparams)
          || gst_pad_peer_query (GST_BASE_TRANSFORM_SRC_PAD (btrans), queryparams)) { 
        if (gst_nvquery_batch_size_parse (queryparams, &batch_size)) { 
          dsexample->batch_size = batch_size;
        }
      }
      GST_DEBUG_OBJECT (dsexample, "Setting batch-size %d \n",
          dsexample->batch_size);
      gst_query_unref (queryparams);
    
      if (dsexample->process_full_frame && dsexample->blur_objects) { 
        GST_ERROR ("Error: does not support blurring while processing full frame");
        goto error;
      }
    
      CHECK_CUDA_STATUS (cudaStreamCreate (&dsexample->cuda_stream),
          "Could not create cuda stream");
    
      if (dsexample->inter_buf)
        NvBufSurfaceDestroy (dsexample->inter_buf);
      dsexample->inter_buf = NULL;
    
      /* An intermediate buffer for NV12/RGBA to BGR conversion will be * required. Can be skipped if custom algorithm can work directly on NV12/RGBA. */
      create_params.gpuId  = dsexample->gpu_id;
      create_params.width  = dsexample->processing_width;
      create_params.height = dsexample->processing_height;
      create_params.size = 0;
      create_params.colorFormat = NVBUF_COLOR_FORMAT_RGBA;
      create_params.layout = NVBUF_LAYOUT_PITCH;
    #ifdef __aarch64__
      create_params.memType = NVBUF_MEM_DEFAULT;
    #else
      create_params.memType = NVBUF_MEM_CUDA_UNIFIED;
    #endif
    
      if (NvBufSurfaceCreate (&dsexample->inter_buf, 1,
              &create_params) != 0) { 
        GST_ERROR ("Error: Could not allocate internal buffer for dsexample");
        goto error;
      }
    
      /* Create host memory for storing converted/scaled interleaved RGB data */
      CHECK_CUDA_STATUS (cudaMallocHost (&dsexample->host_rgb_buf,
              dsexample->processing_width * dsexample->processing_height *
              RGB_BYTES_PER_PIXEL), "Could not allocate cuda host buffer");
    
      GST_DEBUG_OBJECT (dsexample, "allocated cuda buffer %p \n",
          dsexample->host_rgb_buf);
    
      /* CV Mat containing interleaved RGB data. This call does not allocate memory. * It uses host_rgb_buf as data. */
      dsexample->cvmat =
          new cv::Mat (dsexample->processing_height, dsexample->processing_width,
          CV_8UC3, dsexample->host_rgb_buf,
          dsexample->processing_width * RGB_BYTES_PER_PIXEL);
    
      if (!dsexample->cvmat)
        goto error;
    
      GST_DEBUG_OBJECT (dsexample, "created CV Mat\n");
    
      return TRUE;
    error:
      if (dsexample->host_rgb_buf) { 
        cudaFreeHost (dsexample->host_rgb_buf);
        dsexample->host_rgb_buf = NULL;
      }
    
      if (dsexample->cuda_stream) { 
        cudaStreamDestroy (dsexample->cuda_stream);
        dsexample->cuda_stream = NULL;
      }
      if (dsexample->dsexamplelib_ctx)
        DsExampleCtxDeinit (dsexample->dsexamplelib_ctx);
      return FALSE;
    }
    
    /** * Stop the output thread and free up all the resources */
    static gboolean
    gst_dsexample_stop (GstBaseTransform * btrans)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
    
      if (dsexample->inter_buf)
        NvBufSurfaceDestroy(dsexample->inter_buf);
      dsexample->inter_buf = NULL;
    
      if (dsexample->cuda_stream)
        cudaStreamDestroy (dsexample->cuda_stream);
      dsexample->cuda_stream = NULL;
    
      delete dsexample->cvmat;
      dsexample->cvmat = NULL;
    
      if (dsexample->host_rgb_buf) { 
        cudaFreeHost (dsexample->host_rgb_buf);
        dsexample->host_rgb_buf = NULL;
      }
    
      GST_DEBUG_OBJECT (dsexample, "deleted CV Mat \n");
    
      /* Deinit the algorithm library */
      DsExampleCtxDeinit (dsexample->dsexamplelib_ctx);
      dsexample->dsexamplelib_ctx = NULL;
    
      GST_DEBUG_OBJECT (dsexample, "ctx lib released \n");
    
      return TRUE;
    }
    
    /** * Called when source / sink pad capabilities have been negotiated. */
    static gboolean
    gst_dsexample_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
        GstCaps * outcaps)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      /* Save the input video information, since this will be required later. */
      gst_video_info_from_caps (&dsexample->video_info, incaps);
    
      if (dsexample->blur_objects && !dsexample->process_full_frame) { 
        /* requires RGBA format for blurring the objects in opencv */
         if (dsexample->video_info.finfo->format != GST_VIDEO_FORMAT_RGBA) { 
          GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
              ("input format should be RGBA when using blur-objects property"), (NULL));
          goto error;
          }
      }
    
      return TRUE;
    
    error:
      return FALSE;
    }
    
    /** * Scale the entire frame to the processing resolution maintaining aspect ratio. * Or crop and scale objects to the processing resolution maintaining the aspect * ratio. Remove the padding required by hardware and convert from RGBA to RGB * using openCV. These steps can be skipped if the algorithm can work with * padded data and/or can work with RGBA. */
    static GstFlowReturn
    get_converted_mat (GstDsExample * dsexample, NvBufSurface *input_buf, gint idx,
        NvOSD_RectParams * crop_rect_params, gdouble & ratio, gint input_width,
        gint input_height)
    { 
      NvBufSurfTransform_Error err;
      NvBufSurfTransformConfigParams transform_config_params;
      NvBufSurfTransformParams transform_params;
      NvBufSurfTransformRect src_rect;
      NvBufSurfTransformRect dst_rect;
      NvBufSurface ip_surf;
      cv::Mat in_mat;
      ip_surf = *input_buf;
    
      ip_surf.numFilled = ip_surf.batchSize = 1;
      ip_surf.surfaceList = &(input_buf->surfaceList[idx]);
    
      gint src_left = GST_ROUND_UP_2((unsigned int)crop_rect_params->left);
      gint src_top = GST_ROUND_UP_2((unsigned int)crop_rect_params->top);
      gint src_width = GST_ROUND_DOWN_2((unsigned int)crop_rect_params->width);
      gint src_height = GST_ROUND_DOWN_2((unsigned int)crop_rect_params->height);
    
      /* Maintain aspect ratio */
      double hdest = dsexample->processing_width * src_height / (double) src_width;
      double wdest = dsexample->processing_height * src_width / (double) src_height;
      guint dest_width, dest_height;
    
      if (hdest <= dsexample->processing_height) { 
        dest_width = dsexample->processing_width;
        dest_height = hdest;
      } else { 
        dest_width = wdest;
        dest_height = dsexample->processing_height;
      }
    
      /* Configure transform session parameters for the transformation */
      transform_config_params.compute_mode = NvBufSurfTransformCompute_Default;
      transform_config_params.gpu_id = dsexample->gpu_id;
      transform_config_params.cuda_stream = dsexample->cuda_stream;
    
      /* Set the transform session parameters for the conversions executed in this * thread. */
      err = NvBufSurfTransformSetSessionParams (&transform_config_params);
      if (err != NvBufSurfTransformError_Success) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvBufSurfTransformSetSessionParams failed with error %d", err), (NULL));
        goto error;
      }
    
      /* Calculate scaling ratio while maintaining aspect ratio */
      ratio = MIN (1.0 * dest_width/ src_width, 1.0 * dest_height / src_height);
    
      if ((crop_rect_params->width == 0) || (crop_rect_params->height == 0)) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("%s:crop_rect_params dimensions are zero",__func__), (NULL));
        goto error;
      }
    
    #ifdef __aarch64__
      if (ratio <= 1.0 / 16 || ratio >= 16.0) { 
        /* Currently cannot scale by ratio > 16 or < 1/16 for Jetson */
        goto error;
      }
    #endif
      /* Set the transform ROIs for source and destination */
      src_rect = { (guint)src_top, (guint)src_left, (guint)src_width, (guint)src_height};
      dst_rect = { 0, 0, (guint)dest_width, (guint)dest_height};
    
      /* Set the transform parameters */
      transform_params.src_rect = &src_rect;
      transform_params.dst_rect = &dst_rect;
      transform_params.transform_flag =
        NVBUFSURF_TRANSFORM_FILTER | NVBUFSURF_TRANSFORM_CROP_SRC |
          NVBUFSURF_TRANSFORM_CROP_DST;
      transform_params.transform_filter = NvBufSurfTransformInter_Default;
    
      /* Memset the memory */
      NvBufSurfaceMemSet (dsexample->inter_buf, 0, 0, 0);
    
      GST_DEBUG_OBJECT (dsexample, "Scaling and converting input buffer\n");
    
      /* Transformation scaling+format conversion if any. */
      err = NvBufSurfTransform (&ip_surf, dsexample->inter_buf, &transform_params);
      if (err != NvBufSurfTransformError_Success) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvBufSurfTransform failed with error %d while converting buffer", err),
            (NULL));
        goto error;
      }
      /* Map the buffer so that it can be accessed by CPU */
      if (NvBufSurfaceMap (dsexample->inter_buf, 0, 0, NVBUF_MAP_READ) != 0){ 
        goto error;
      }
    
      /* Cache the mapped data for CPU access */
      NvBufSurfaceSyncForCpu (dsexample->inter_buf, 0, 0);
    
      /* Use openCV to remove padding and convert RGBA to BGR. Can be skipped if * algorithm can handle padded RGBA data. */
      in_mat =
          cv::Mat (dsexample->processing_height, dsexample->processing_width,
          CV_8UC4, dsexample->inter_buf->surfaceList[0].mappedAddr.addr[0],
          dsexample->inter_buf->surfaceList[0].pitch);
    
    #if (CV_MAJOR_VERSION >= 4)
      cv::cvtColor (in_mat, *dsexample->cvmat, cv::COLOR_RGBA2BGR);
    #else
      cv::cvtColor (in_mat, *dsexample->cvmat, CV_RGBA2BGR);
    #endif
    
      if (NvBufSurfaceUnMap (dsexample->inter_buf, 0, 0)){ 
        goto error;
      }
    
    #ifdef __aarch64__
      /* To use the converted buffer in CUDA, create an EGLImage and then use * CUDA-EGL interop APIs */
      if (USE_EGLIMAGE) { 
        if (NvBufSurfaceMapEglImage (dsexample->inter_buf, 0) !=0 ) { 
          goto error;
        }
    
        /* dsexample->inter_buf->surfaceList[0].mappedAddr.eglImage * Use interop APIs cuGraphicsEGLRegisterImage and * cuGraphicsResourceGetMappedEglFrame to access the buffer in CUDA */
    
        /* Destroy the EGLImage */
        NvBufSurfaceUnMapEglImage (dsexample->inter_buf, 0);
      }
    #endif
    
      /* We will first convert only the Region of Interest (the entire frame or the * object bounding box) to RGB and then scale the converted RGB frame to * processing resolution. */
      return GST_FLOW_OK;
    
    error:
      return GST_FLOW_ERROR;
    }
    
    /* * Blur the detected objects when processing in object mode (full-frame=0) */
    static GstFlowReturn
    blur_objects (GstDsExample * dsexample, gint idx,
        NvOSD_RectParams * crop_rect_params, cv::Mat in_mat)
    { 
      cv::Rect crop_rect;
    
      if ((crop_rect_params->width == 0) || (crop_rect_params->height == 0)) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("%s:crop_rect_params dimensions are zero",__func__), (NULL));
        return GST_FLOW_ERROR;
      }
    
    /* rectangle for cropped objects */
      crop_rect = cv::Rect (crop_rect_params->left, crop_rect_params->top,
      crop_rect_params->width, crop_rect_params->height);
    
    /* apply gaussian blur to the detected objects */
      //GaussianBlur(in_mat(crop_rect), in_mat(crop_rect), cv::Size(15,15), 4);
    
      return GST_FLOW_OK;
    }
    
    /** * Called when element recieves an input buffer from upstream element. */
    static GstFlowReturn
    gst_dsexample_transform_ip (GstBaseTransform * btrans, GstBuffer * inbuf)
    { 
      GstDsExample *dsexample = GST_DSEXAMPLE (btrans);
      GstMapInfo in_map_info;
      GstFlowReturn flow_ret = GST_FLOW_ERROR;
      gdouble scale_ratio = 1.0;
      DsExampleOutput *output;
    
      NvBufSurface *surface = NULL;
      NvDsBatchMeta *batch_meta = NULL;
      NvDsFrameMeta *frame_meta = NULL;
      NvDsMetaList * l_frame = NULL;
      guint i = 0;
    
      dsexample->frame_num++;
      CHECK_CUDA_STATUS (cudaSetDevice (dsexample->gpu_id),
          "Unable to set cuda device");
    
      memset (&in_map_info, 0, sizeof (in_map_info));
      if (!gst_buffer_map (inbuf, &in_map_info, GST_MAP_READ)) { 
        g_print ("Error: Failed to map gst buffer\n");
        goto error;
      }
    
      nvds_set_input_system_timestamp (inbuf, GST_ELEMENT_NAME (dsexample));
      surface = (NvBufSurface *) in_map_info.data;
      GST_DEBUG_OBJECT (dsexample,
          "Processing Frame %" G_GUINT64_FORMAT " Surface %p\n",
          dsexample->frame_num, surface);
    
      if (CHECK_NVDS_MEMORY_AND_GPUID (dsexample, surface))
        goto error;
    
      batch_meta = gst_buffer_get_nvds_batch_meta (inbuf);
      if (batch_meta == nullptr) { 
        GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
            ("NvDsBatchMeta not found for input buffer."), (NULL));
        return GST_FLOW_ERROR;
      }
    
      if (dsexample->process_full_frame) { 
        for (l_frame = batch_meta->frame_meta_list; l_frame != NULL;
          l_frame = l_frame->next)
        { 
          frame_meta = (NvDsFrameMeta *) (l_frame->data);
          NvOSD_RectParams rect_params;
    
          /* Scale the entire frame to processing resolution */
          rect_params.left = 0;
          rect_params.top = 0;
          rect_params.width = dsexample->video_info.width;
          rect_params.height = dsexample->video_info.height;
    
          /* Scale and convert the frame */
          if (get_converted_mat (dsexample, surface, i, &rect_params,
                scale_ratio, dsexample->video_info.width,
                dsexample->video_info.height) != GST_FLOW_OK) { 
            goto error;
          }
    
          /* Process to get the output */
          output =
              DsExampleProcess (dsexample->dsexamplelib_ctx,
              dsexample->cvmat->data);
          /* Attach the metadata for the full frame */
          attach_metadata_full_frame (dsexample, frame_meta, scale_ratio, output, i);
          i++;
          free (output);
        }
    
      } else { 
        /* Using object crops as input to the algorithm. The objects are detected by * the primary detector */
        NvDsMetaList * l_obj = NULL;
        NvDsObjectMeta *obj_meta = NULL;
    
    #ifndef __aarch64__
        if (dsexample->blur_objects) { 
          if (surface->memType != NVBUF_MEM_CUDA_UNIFIED){ 
            GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                ("%s:need NVBUF_MEM_CUDA_UNIFIED memory for opencv blurring",__func__), (NULL));
            return GST_FLOW_ERROR;
          }
        }
    #endif
    
        for (l_frame = batch_meta->frame_meta_list; l_frame != NULL;
          l_frame = l_frame->next)
        { 
          frame_meta = (NvDsFrameMeta *) (l_frame->data);
          cv::Mat in_mat;
    
          if (dsexample->blur_objects) { 
            /* Map the buffer so that it can be accessed by CPU */
            if (surface->surfaceList[frame_meta->batch_id].mappedAddr.addr[0] == NULL){ 
              if (NvBufSurfaceMap (surface, frame_meta->batch_id, 0, NVBUF_MAP_READ_WRITE) != 0){ 
                GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                    ("%s:buffer map to be accessed by CPU failed", __func__), (NULL));
                return GST_FLOW_ERROR;
              }
            }
    
            /* Cache the mapped data for CPU access */
            NvBufSurfaceSyncForCpu (surface, frame_meta->batch_id, 0);
    
            in_mat =
                cv::Mat (surface->surfaceList[frame_meta->batch_id].planeParams.height[0],
                surface->surfaceList[frame_meta->batch_id].planeParams.width[0], CV_8UC4,
                surface->surfaceList[frame_meta->batch_id].mappedAddr.addr[0],
                surface->surfaceList[frame_meta->batch_id].planeParams.pitch[0]);
          }
    
          for (l_obj = frame_meta->obj_meta_list; l_obj != NULL;
              l_obj = l_obj->next)
          { 
            obj_meta = (NvDsObjectMeta *) (l_obj->data);
    
            if (dsexample->blur_objects) { 
              /* gaussian blur the detected objects using opencv */
              if (blur_objects (dsexample, frame_meta->batch_id,
                &obj_meta->rect_params, in_mat) != GST_FLOW_OK) { 
              /* Error in blurring, skip processing on object. */
                GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                ("blurring the object failed"), (NULL));
                if (NvBufSurfaceUnMap (surface, frame_meta->batch_id, 0)){ 
                  GST_ELEMENT_ERROR (dsexample, STREAM, FAILED,
                    ("%s:buffer unmap to be accessed by CPU failed", __func__), (NULL));
                }
                return GST_FLOW_ERROR;
              }
              continue;
            }
    
            /* Should not process on objects smaller than MIN_INPUT_OBJECT_WIDTH x MIN_INPUT_OBJECT_HEIGHT * since it will cause hardware scaling issues. */
            if (obj_meta->rect_params.width < MIN_INPUT_OBJECT_WIDTH ||
                obj_meta->rect_params.height < MIN_INPUT_OBJECT_HEIGHT)
              continue;
    
            /* Crop and scale the object */
            if (get_converted_mat (dsexample,
                  surface, frame_meta->batch_id, &obj_meta->rect_params,
                  scale_ratio, dsexample->video_info.width,
                  dsexample->video_info.height) != GST_FLOW_OK) { 
              /* Error in conversion, skip processing on object. */
              continue;
            }
    
            /* Process the object crop to obtain label */
            output = DsExampleProcess (dsexample->dsexamplelib_ctx,
                dsexample->cvmat->data);
    
            /* Attach labels for the object */
            attach_metadata_object (dsexample, obj_meta, output);
    
            free (output);
          }
    
          if (dsexample->blur_objects) { 
          /* Cache the mapped data for device access */
            NvBufSurfaceSyncForDevice (surface, frame_meta->batch_id, 0);
    
    #ifdef DSEXAMPLE_DEBUG
            /* Use openCV to remove padding and convert RGBA to BGR. Can be skipped if * algorithm can handle padded RGBA data. */
    #if (CV_MAJOR_VERSION >= 4)
            cv::cvtColor (in_mat, *dsexample->cvmat, cv::COLOR_RGBA2BGR);
    #else
            cv::cvtColor (in_mat, *dsexample->cvmat, CV_RGBA2BGR);
    #endif
            /* used to dump the converted mat to files for debug */
            static guint cnt = 0;
            cv::imwrite("out_" + std::to_string (cnt) + ".jpeg", *dsexample->cvmat);
            cnt++;
    #endif
          }
        }
      }
      flow_ret = GST_FLOW_OK;
    
    error:
    
      nvds_set_output_system_timestamp (inbuf, GST_ELEMENT_NAME (dsexample));
      gst_buffer_unmap (inbuf, &in_map_info);
      return flow_ret;
    }
    
    /** * Attach metadata for the full frame. We will be adding a new metadata. */
    static void
    attach_metadata_full_frame (GstDsExample * dsexample, NvDsFrameMeta *frame_meta,
        gdouble scale_ratio, DsExampleOutput * output, guint batch_id)
    { 
      NvDsBatchMeta *batch_meta = frame_meta->base_meta.batch_meta;
      NvDsObjectMeta *object_meta = NULL;
      static gchar font_name[] = "Serif";
      GST_DEBUG_OBJECT (dsexample, "Attaching metadata %d\n", output->numObjects);
    
      for (gint i = 0; i < output->numObjects; i++) { 
        DsExampleObject *obj = &output->object[i];
        object_meta = nvds_acquire_obj_meta_from_pool(batch_meta);
        NvOSD_RectParams & rect_params = object_meta->rect_params;
        NvOSD_TextParams & text_params = object_meta->text_params;
    
        /* Assign bounding box coordinates */
        rect_params.left = obj->left;
        rect_params.top = obj->top;
        rect_params.width = obj->width;
        rect_params.height = obj->height;
    
        /* Semi-transparent yellow background */
        rect_params.has_bg_color = 0;
        rect_params.bg_color = (NvOSD_ColorParams) { 
        1, 1, 0, 0.4};
        /* Red border of width 6 */
        rect_params.border_width = 3;
        rect_params.border_color = (NvOSD_ColorParams) { 
        1, 0, 0, 1};
    
        /* Scale the bounding boxes proportionally based on how the object/frame was * scaled during input */
        rect_params.left /= scale_ratio;
        rect_params.top /= scale_ratio;
        rect_params.width /= scale_ratio;
        rect_params.height /= scale_ratio;
        GST_DEBUG_OBJECT (dsexample, "Attaching rect%d of batch%u"
            " left->%f top->%f width->%f"
            " height->%f label->%s\n", i, batch_id, rect_params.left,
            rect_params.top, rect_params.width, rect_params.height, obj->label);
    
        object_meta->object_id = UNTRACKED_OBJECT_ID;
        g_strlcpy (object_meta->obj_label, obj->label, MAX_LABEL_SIZE);
        /* display_text required heap allocated memory */
        text_params.display_text = g_strdup (obj->label);
        /* Display text above the left top corner of the object */
        text_params.x_offset = rect_params.left;
        text_params.y_offset = rect_params.top - 10;
        /* Set black background for the text */
        text_params.set_bg_clr = 1;
        text_params.text_bg_clr = (NvOSD_ColorParams) { 
        0, 0, 0, 1};
        /* Font face, size and color */
        text_params.font_params.font_name = font_name;
        text_params.font_params.font_size = 11;
        text_params.font_params.font_color = (NvOSD_ColorParams) { 
        1, 1, 1, 1};
    
        nvds_add_obj_meta_to_frame(frame_meta, object_meta, NULL);
        frame_meta->bInferDone = TRUE;
      }
    }
    
    /** * Only update string label in an existing object metadata. No bounding boxes. * We assume only one label per object is generated */
    static void
    attach_metadata_object (GstDsExample * dsexample, NvDsObjectMeta * obj_meta,
        DsExampleOutput * output)
    { 
      if (output->numObjects == 0)
        return;
      NvDsBatchMeta *batch_meta = obj_meta->base_meta.batch_meta;
    
      NvDsClassifierMeta *classifier_meta =
        nvds_acquire_classifier_meta_from_pool (batch_meta);
    
      classifier_meta->unique_component_id = dsexample->unique_id;
    
      NvDsLabelInfo *label_info =
        nvds_acquire_label_info_meta_from_pool (batch_meta);
      g_strlcpy (label_info->result_label, output->object[0].label, MAX_LABEL_SIZE);
      nvds_add_label_info_meta_to_classifier(classifier_meta, label_info);
      nvds_add_classifier_meta_to_object (obj_meta, classifier_meta);
    
      nvds_acquire_meta_lock (batch_meta);
      NvOSD_TextParams & text_params = obj_meta->text_params;
      NvOSD_RectParams & rect_params = obj_meta->rect_params;
    
      /* Below code to display the result */
      /* Set black background for the text * display_text required heap allocated memory */
      if (text_params.display_text) { 
        gchar *conc_string = g_strconcat (text_params.display_text, " ",
            output->object[0].label, NULL);
        g_free (text_params.display_text);
        text_params.display_text = conc_string;
      } else { 
        /* Display text above the left top corner of the object */
        text_params.x_offset = rect_params.left;
        text_params.y_offset = rect_params.top - 10;
        text_params.display_text = g_strdup (output->object[0].label);
        /* Font face, size and color */
        text_params.font_params.font_name = (char *)"Serif";
        text_params.font_params.font_size = 11;
        text_params.font_params.font_color = (NvOSD_ColorParams) { 
        1, 1, 1, 1};
        /* Set black background for the text */
        text_params.set_bg_clr = 1;
        text_params.text_bg_clr = (NvOSD_ColorParams) { 
        0, 0, 0, 1};
      }
      nvds_release_meta_lock (batch_meta);
    }
    
    /** * Boiler plate for registering a plugin and an element. */
    static gboolean
    dsexample_plugin_init (GstPlugin * plugin)
    { 
      GST_DEBUG_CATEGORY_INIT (gst_dsexample_debug, "dsexample", 0,
          "dsexample plugin");
    
      return gst_element_register (plugin, "dsexample", GST_RANK_PRIMARY,
          GST_TYPE_DSEXAMPLE);
    }
    
    GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
        GST_VERSION_MINOR,
        nvdsgst_dsexample,
        DESCRIPTION, dsexample_plugin_init, DS_VERSION, LICENSE, BINARY_PACKAGE, URL)