How to convert object image to base64

Accelerated Computing Intelligent Video Analytics DeepStream SDK
2

I write some code:

#include <gst/gst.h>
#include <glib.h>
#include <iostream>
#include <unordered_map>
#include <sstream>
#include "gstnvdsmeta.h"
#include "nvds_analytics_meta.h"

#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"

#include <cuda.h>
#include <cuda_runtime.h>
#include "nvbufsurface.h"
#include "nvbufsurftransform.h"

/* parse_nvdsanalytics_meta_data
 * and extract nvanalytics metadata etc. */
extern "C" bool
parse_nvdsanalytics_meta_data (NvDsObjectMeta *obj_meta)
{
    gboolean objectIsAnalytics = FALSE;
    for (NvDsMetaList *l_user_meta = obj_meta->obj_user_meta_list; l_user_meta != NULL;
                    l_user_meta = l_user_meta->next) {
        NvDsUserMeta *user_meta = (NvDsUserMeta *) (l_user_meta->data);
        if(user_meta->base_meta.meta_type == NVDS_USER_OBJ_META_NVDSANALYTICS)
        {
//            g_print("in parse_nvdsanalytics_meta_data %d");
            objectIsAnalytics = TRUE;
        }
    }
    return objectIsAnalytics;
}

extern "C" void
enc_object2base64(NvBufSurface *input_buf, gint idx, NvDsFrameMeta *frame_meta)
{
    NvBufSurface ip_surf;
    NvBufSurfTransformRect src_rect, dst_rect;

    ip_surf = *input_buf;

    ip_surf.numFilled = ip_surf.batchSize = 1;
    ip_surf.surfaceList = &(input_buf->surfaceList[idx]);


    int batch_size= input_buf->batchSize;
    printf("\nBatch Size : %d, resolution : %dx%d \n",batch_size,
        input_buf->surfaceList[idx].width, input_buf->surfaceList[idx].height);

    src_rect.top   = 0;
    src_rect.left  = 0;
    src_rect.width = (guint) input_buf->surfaceList[idx].width;
    src_rect.height= (guint) input_buf->surfaceList[idx].height;

    dst_rect.top   = 0;
    dst_rect.left  = 0;
    dst_rect.width = (guint) input_buf->surfaceList[idx].width;
    dst_rect.height= (guint) input_buf->surfaceList[idx].height;

    NvBufSurfTransformParams nvbufsurface_params;
    nvbufsurface_params.src_rect = &src_rect;
    nvbufsurface_params.dst_rect = &dst_rect;
    nvbufsurface_params.transform_flag =  NVBUFSURF_TRANSFORM_CROP_SRC | NVBUFSURF_TRANSFORM_CROP_DST;
    nvbufsurface_params.transform_filter = NvBufSurfTransformInter_Default;

    NvBufSurface *dst_surface = NULL;
    NvBufSurfaceCreateParams nvbufsurface_create_params;

    /* An intermediate buffer for NV12/RGBA to BGR conversion  will be
     * required. Can be skipped if custom algorithm can work directly on NV12/RGBA. */
    nvbufsurface_create_params.gpuId  = input_buf->gpuId;
    nvbufsurface_create_params.width  = (gint) input_buf->surfaceList[idx].width;
    nvbufsurface_create_params.height = (gint) input_buf->surfaceList[idx].height;
    nvbufsurface_create_params.size = 0;
    nvbufsurface_create_params.colorFormat = NVBUF_COLOR_FORMAT_RGBA;
    nvbufsurface_create_params.layout = NVBUF_LAYOUT_PITCH;
    nvbufsurface_create_params.memType = NVBUF_MEM_DEFAULT;

    cudaError_t cuda_err;

    cuda_err = cudaSetDevice (input_buf->gpuId);
    if (cuda_err != cudaSuccess){
        g_print("Cuda set device error");
    }

    cudaStream_t cuda_stream;

    cuda_err=cudaStreamCreate (&cuda_stream);
    if (cuda_err != cudaSuccess){
        g_print("Cuda create stream error");
    }

    int create_result = NvBufSurfaceCreate(&dst_surface,1,&nvbufsurface_create_params);
    if (create_result != 0){
        g_print("NvBufSurfaceCreate Error\n");
    }

    NvBufSurfTransformConfigParams transform_config_params;
    NvBufSurfTransform_Error err;

    transform_config_params.compute_mode = NvBufSurfTransformCompute_Default;
    transform_config_params.gpu_id = input_buf->gpuId;
    transform_config_params.cuda_stream = cuda_stream;
    err = NvBufSurfTransformSetSessionParams (&transform_config_params);

    if (err != NvBufSurfTransformError_Success) {
        g_print ("NvBufSurfTransformSetSessionParams failed with error %d while setting parameter\n", err);
    }

    NvBufSurfaceMemSet (dst_surface, frame_meta->batch_id, 0, 0);
    err = NvBufSurfTransform (&ip_surf, dst_surface, &nvbufsurface_params);

    if (err != NvBufSurfTransformError_Success) {
  	  g_print ("NvBufSurfTransform failed with error %d while converting buffer\n", err);
    }

    NvBufSurfaceMap (dst_surface, frame_meta->batch_id, 0, NVBUF_MAP_READ_WRITE);
    NvBufSurfaceSyncForCpu (dst_surface, frame_meta->batch_id, 0);
//
    cv::Mat in_mat =
            cv::Mat (dst_surface->surfaceList[frame_meta->batch_id].planeParams.height[0],
            dst_surface->surfaceList[frame_meta->batch_id].planeParams.width[0], CV_8UC4,
            dst_surface->surfaceList[frame_meta->batch_id].mappedAddr.addr[0],
            dst_surface->surfaceList[frame_meta->batch_id].planeParams.pitch[0]);

    //try to write out image to disk
    cv::imwrite("out.jpeg", in_mat);
    // convert in_mat to base64 string 
    //....
    //

    NvBufSurfaceUnMap (dst_surface, 0, 0);
    NvBufSurfaceDestroy (dst_surface);
    cudaStreamDestroy (cuda_stream);
}

make not error, but when i run so get Segmentation fault (core dumped) at line: cv::imwrite(“out.jpeg”, in_mat);
help me