兼容旧版本的功能

入参：resize_param_in_msg

出参：resize_param_out_msg

入参：vpc_in_msg

调用示例

• VPC基础功能调用示例

  gXxxxx为配置参数，参数配置与VPC调用分为两个阶段。

  Step1：通过DVPP_CTL_TOOL_CASE_GET_RESIZE_PARAM命令字调用DvppCtl，获取配置参数，DvppCtl的入参为resize_paramo_in_msg，出参为resize_param_out_msg。即通过resize_param_in_msg将原始图片的宽高，裁剪区域(hmax,hmin,vamx,vmin)，以及输出宽高等参数传给DVPP，DVPP通过计算将重新生成的裁剪区域(hmax,hmin,vamx,vmin)以及缩放比(hinc,vinc)返回给调用方。

  Step2：调用方将第一步返回的参数通过vpc_in_msg结构体传递给DVPP，并将DvppCtl调用命令字改为DVPP_CTL_VPC_PROC，执行并获得处理结果。

      dvppapi_ctl_msg dvppApiCtlMsg;
      vpc_in_msg vpcInMsg;
      resize_param_in_msg resize_in_param;
      resize_param_out_msg resize_out_param;
      resize_in_param.src_width = gWidth;
      resize_in_param.src_high = gHigh;
      resize_in_param.hmax = gHmax;
      resize_in_param.hmin = gHmin;
      resize_in_param.vmax = gVmax;
      resize_in_param.vmin = gVmin;
      resize_in_param.dest_width = floor(gHinc * (gHmax - gHmin + 1) + 0.5);
      resize_in_param.dest_high = floor(gVinc * (gVmax - gVmin + 1) + 0.5);
      printf("width  =%d\n", gWidth);
      printf("high   =%d\n", gHigh);
      printf("hmax   =%d\n", gHmax);
      printf("hmin   =%d\n", gHmin);
      printf("vmax   =%d\n", gVmax);
      printf("vmin   =%d\n", gVmin);
      printf("out width   =%d\n", resize_in_param.dest_width);
      printf("out hight   =%d\n", resize_in_param.dest_high );
  
      dvppApiCtlMsg.in = (void *)(&resize_in_param);
      dvppApiCtlMsg.out = (void *)(&resize_out_param);
      IDVPPAPI *pidvppapi = NULL;
      CreateDvppApi(pidvppapi);
      if (DvppCtl(pidvppapi, DVPP_CTL_TOOL_CASE_GET_RESIZE_PARAM, &dvppApiCtlMsg) != 0) {
          printf("call DVPP_CTL_TOOL_CASE_GET_RESIZE_PARAM process faild!\n");
          DestroyDvppApi(pidvppapi);
          return;
      }
  
      int bufferSize        = 0;
      vpcInMsg.format       = gFormat;
      vpcInMsg.cvdr_or_rdma = gcvdr_or_rdma;
      vpcInMsg.bitwidth = gBitwidth;
      vpcInMsg.rank = gRank;
      vpcInMsg.width = gWidth;
      vpcInMsg.high = gHigh;
      vpcInMsg.stride = gStride;
      vpcInMsg.hmax = resize_out_param.hmax;
      vpcInMsg.hmin = resize_out_param.hmin;
      vpcInMsg.vmax = resize_out_param.vmax;
      vpcInMsg.vmin = resize_out_param.vmin;
      vpcInMsg.vinc = resize_out_param.vinc;
      vpcInMsg.hinc = resize_out_param.hinc;
      printf("resize_out_param.hinc = %lf\n", resize_out_param.hinc);
      printf("resize_out_param.vinc = %lf\n", resize_out_param.vinc);
      printf("resize_out_param.hmax = %d\n", resize_out_param.hmax);
      printf("resize_out_param.hmin = %d\n", resize_out_param.hmin);
      printf("resize_out_param.vmax = %d\n", resize_out_param.vmax);
      printf("resize_out_param.vmin = %d\n", resize_out_param.vmin);
  
      printf("format =%d\n", vpcInMsg.format);
      printf("rank   =%d\n", vpcInMsg.rank);
      printf("width  =%d\n", vpcInMsg.width);
      printf("high   =%d\n", vpcInMsg.high);
      printf("stride =%d\n", vpcInMsg.stride);
      printf("hmax   =%d\n", vpcInMsg.hmax);
      printf("hmin   =%d\n", vpcInMsg.hmin);
      printf("vmax   =%d\n", vpcInMsg.vmax);
      printf("vmin   =%d\n", vpcInMsg.vmin);
      printf("vinc   =%F\n", vpcInMsg.vinc);
      printf("hinc   =%F\n", vpcInMsg.hinc);
      if (vpcInMsg.cvdr_or_rdma == 0) {
          printf("rdma channel\n");
          int buffersize ;
          char * payloadY ;
          char * payloadC ;
          char * headY ;
          char * headC ;
          FILE * rdmaimage = fopen(in_file_name, "rb");
  
          if (vpcInMsg.bitwidth == 10) {
              buffersize                        = vpcInMsg.width  * vpcInMsg.high * 2 + 512 * 1024;
              payloadY                          = (char*)memalign(128, buffersize);
              headY                             = payloadY + vpcInMsg.width  * vpcInMsg.high * 2;
              headC                             = headY + 256 * 1024;
              vpcInMsg.rdma.luma_payload_addr   = (long)payloadY;
              vpcInMsg.rdma.chroma_payload_addr = (long)payloadY + 640;
          } else {
              buffersize                        = vpcInMsg.width * vpcInMsg.high * 1.5 + 512 * 1024;
              payloadY                          = (char*)memalign(128, buffersize);
              payloadC                          = payloadY + vpcInMsg.width * vpcInMsg.high;
              headY                             = payloadC + vpcInMsg.width * vpcInMsg.high / 2;
              headC                             = headY + 256 * 1024;
              vpcInMsg.rdma.luma_payload_addr   = (long)payloadY;
              vpcInMsg.rdma.chroma_payload_addr = (long)payloadC;
          }
  
          fread(payloadY, 1, buffersize, rdmaimage);
          vpcInMsg.rdma.luma_head_addr        = (long)headY;
          vpcInMsg.rdma.chroma_head_addr      = (long)headC;
          vpcInMsg.rdma.luma_head_stride      = vpcInMsg.stride;
          vpcInMsg.rdma.chroma_head_stride    = vpcInMsg.stride;
          vpcInMsg.rdma.luma_payload_stride   = gpYStride;
          vpcInMsg.rdma.chroma_payload_stride = gpUVStride;
          fclose(rdmaimage);
          printf("luma payload stride= %d\n", vpcInMsg.rdma.luma_payload_stride );
          printf("chroma payload stride= %d\n", vpcInMsg.rdma.chroma_payload_stride );
      } else {
          alloc_buffer(vpcInMsg.width, vpcInMsg.high, vpcInMsg.stride, bufferSize);
          if (open_image(in_file_name, vpcInMsg.width, vpcInMsg.high, vpcInMsg.stride) != 0) {
              printf("open file failed~\n");
              free(in_buffer);
              return;
          }
          vpcInMsg.in_buffer      = in_buffer;
          vpcInMsg.in_buffer_size = bufferSize;
      }
      //alloc in and out buffer
      shared_ptr<AutoBuffer> auto_out_buffer = make_shared<AutoBuffer>();
      vpcInMsg.auto_out_buffer_1             = auto_out_buffer;
      dvppApiCtlMsg.in                       = (void *)(&vpcInMsg);
      dvppApiCtlMsg.in_size                  = sizeof(vpc_in_msg);
  
      if (pidvppapi != NULL) {
  
          for (int i = 0; i < gLoop; i++) {
              if (DvppCtl(pidvppapi, DVPP_CTL_VPC_PROC, &dvppApiCtlMsg) != 0) {
                  printf("call dvppctl process faild!\n");
                  DestroyDvppApi(pidvppapi);
                  free(in_buffer);
                  return;
              }
          }
  
      } else {
          printf("pidvppapi is null!\n");
      }
  
      free(in_buffer);
  
      FILE *fp = NULL;
      fp = fopen(out_file_name, "wb+");
      if (fp == NULL) {
          printf("open file %s failed~\n", out_file_name);
          free(in_buffer);
          return;
      }
  
      fwrite(vpcInMsg.auto_out_buffer_1->getBuffer(), 1, vpcInMsg.auto_out_buffer_1->getBufferSize(), fp);
      fflush(fp);
      fclose(fp);
      DestroyDvppApi(pidvppapi);
      return;

• RawData8k基础功能调用示例

  参数配置：

      dvppapi_ctl_msg dvppApiCtlMsg;
      vpc_in_msg vpcInMsg;
      vpcInMsg.width = gWidth;
      vpcInMsg.high = gHigh;
      vpcInMsg.stride = gStride;
      vpcInMsg.out_width = gOutWidth;
      vpcInMsg.out_high = gOutHigh;
      printf("width     =%d\n", vpcInMsg.width);
      printf("high      =%d\n", vpcInMsg.high);
      printf("stride    =%d\n", vpcInMsg.stride);
      printf("out_width =%d\n", vpcInMsg.out_width);
      printf("out_high  =%d\n", vpcInMsg.out_high);
      //alloc in and out buffer
      char *in_buffer = (char *)malloc(vpcInMsg.width * vpcInMsg.high * 1.5);
      if (in_buffer = NULL) {
          printf("malloc fail\n");
          return;
      }
  
      shared_ptr<AutoBuffer> auto_out_buffer = make_shared<AutoBuffer>();
      FILE *yuvimage = fopen(in_file_name, "rb");
      if (yuvimage == NULL) {
          printf("no such file!,file_name=[%s]\n", in_file_name);
          free(in_buffer);
          return;
      } else {
          fread(in_buffer, 1, vpcInMsg.width * vpcInMsg.high * 3 / 2, yuvimage);
      }
  
      vpcInMsg.rank = gRank;
      vpcInMsg.in_buffer = in_buffer;
      vpcInMsg.in_buffer_size = vpcInMsg.width * vpcInMsg.high * 1.5;
      vpcInMsg.auto_out_buffer_1 = auto_out_buffer;
      vpcInMsg.use_flag = 1;
      dvppApiCtlMsg.in = (void *)(&vpcInMsg);
      dvppApiCtlMsg.in_size = sizeof(vpc_in_msg);
      IDVPPAPI *pidvppapi = NULL;
      CreateDvppApi(pidvppapi);
      if (pidvppapi != NULL) {
          if (DvppCtl(pidvppapi, DVPP_CTL_VPC_PROC, &dvppApiCtlMsg) != 0) {
              printf("call dvppctl process faild!\n");
              DestroyDvppApi(pidvppapi);
              free(in_buffer);
              fclose(yuvimage);
              return;
          }
      } else {
          printf("pidvppapi is null!\n");
      }
  
      DestroyDvppApi(pidvppapi);
      FILE *fp = NULL;
      fp = fopen(out_file_name, "wb+");
      if (fp != NULL) {
          fwrite(vpcInMsg.auto_out_buffer_1->getBuffer(), 1, vpcInMsg.auto_out_buffer_1->getBufferSize(), fp);
          fflush(fp);
          fclose(fp);
      } else {
          fclose(yuvimage);
          return;
      }
  
      free(in_buffer);
      fclose(yuvimage);
      return;

• Rawdata叠加基础功能调用实例

      dvppapi_ctl_msg dvppApiCtlMsg;
      vpc_in_msg vpcInMsg;
      //配置RawData叠加参数
      vpcInMsg.use_flag = 2;
      vpcInMsg.overlay.image_type = 0;
      vpcInMsg.overlay.image_rank_type = 0;
      vpcInMsg.overlay.bit_width = 8;
      vpcInMsg.overlay.in_width_image = 1000;
      vpcInMsg.overlay.in_high_image = 1000;
      vpcInMsg.overlay.in_width_text = 500;
      vpcInMsg.overlay.in_high_text = 390;
      vpcInMsg.overlay.image_width_stride = 2;
      vpcInMsg.overlay.image_high_stride = 2;
      vpcInMsg.overlay.text_width_stride = 2;
      vpcInMsg.overlay.text_high_stride = 2;
      vpcInMsg.overlay.in_buffer_image = NULL;
      vpcInMsg.overlay.in_buffer_text = NULL;
      vpcInMsg.overlay.auto_overlay_out_buffer = make_shared<AutoBuffer>();
      //初始化图像内存
      if(NULL == (vpcInMsg.overlay.in_buffer_image = (char*)malloc(vpcInMsg.overlay.in_width_image*vpcInMsg.overlay.in_high_image*3/2)))    {
          printf("in_buffer_image alloc failed!\n");
          return ;
      }
      //打开图片至申请的内存中
      char image_file[50] = "yuv_data_0";
      FILE * yuvimage = fopen(image_file,"rb");
      if(NULL == yuvimage)    {
          printf("VPC_TEST: yuv image open faild!");
          return ;
      }    else    {
          fread(vpcInMsg.overlay.in_buffer_image, 1,vpcInMsg.overlay.in_width_image*vpcInMsg.overlay.in_high_image*3/2,yuvimage);
          fclose(yuvimage);
          yuvimage = NULL;
  }
  
      //初始化文字内存
      if(NULL == (vpcInMsg.overlay.in_buffer_text = (char*)malloc(vpcInMsg.overlay.in_width_text*vpcInMsg.overlay.in_high_text*3/2)))    {
          printf("in_buffer_text alloc failed!");
          free(vpcInMsg.overlay.in_buffer_image);
          return ;
      }
  
      //打开text图片至申请的内存中
      char text_file[50] = "text_0";
      FILE * yuvtext = fopen(text_file,"rb");
      if(NULL == yuvtext)    {
          printf("VPC_TEST: yuv text image open faild!");
          free(vpcInMsg.overlay.in_buffer_image);
          return ;
      }    else    {
          fread(vpcInMsg.overlay.in_buffer_text, 1,vpcInMsg.overlay.in_width_text*vpcInMsg.overlay.in_high_text*3/2, yuvtext);
          fclose(yuvtext);
          yuvtext = NULL;
      }
  
      dvppApiCtlMsg.in = (void*)(&vpcInMsg);
      dvppApiCtlMsg.in_size = sizeof(vpc_in_msg);
      IDVPPAPI *pidvppapi = NULL;
      CreateDvppApi(pidvppapi);
      if(pidvppapi!=NULL)    {
          if(DvppCtl(pidvppapi,DVPP_CTL_VPC_PROC,&dvppApiCtlMsg)!= 0)        {
              printf("call dvppctl process faild!\n");
              DestroyDvppApi(pidvppapi);
              free(vpcInMsg.overlay.in_buffer_image);
              free(vpcInMsg.overlay.in_buffer_text);
              return ;
          }
          DestroyDvppApi(pidvppapi);
          FILE * fp   = fopen("./out_overlay_image_share","wb+");
          fwrite(vpcInMsg.overlay.auto_overlay_out_buffer->getBuffer(),1,vpcInMsg.overlay.in_width_image*vpcInMsg.overlay.in_high_image*3/2,fp);
          fflush(fp);
          fclose(fp);
          fp=NULL;
          return ;
      }    else    {
          printf("pidvppapi is null!\n");
          return ;
      }
      if(NULL != vpcInMsg.overlay.in_buffer_image)    {
          free(vpcInMsg.overlay.in_buffer_image);
          vpcInMsg.overlay.in_buffer_image = NULL;
      }
      if(NULL != vpcInMsg.overlay.in_buffer_text)    {
          free(vpcInMsg.overlay.in_buffer_text);
          vpcInMsg.overlay.in_buffer_text = NULL;
      }

• Rawdata拼接基础功能调用实例

      dvppapi_ctl_msg dvppApiCtlMsg;
      vpc_in_msg vpcInMsg;
       //配置RawData拼接参数
      vpcInMsg.use_flag = 3;
      vpcInMsg.collage.image_type = 0;
      vpcInMsg.collage.image_rank_type = 0;
      vpcInMsg.collage.bit_width = 8;
      vpcInMsg.collage.in_width = 1000;
      vpcInMsg.collage.in_high = 1000;
      vpcInMsg.collage.width_stride = 2;
      vpcInMsg.collage.high_stride = 2;
      vpcInMsg.collage.collage_type = 0;
      vpcInMsg.collage.auto_out_buffer = make_shared<AutoBuffer>();
      char image_file[4][50] = {"yuv_data_0","yuv_data_1","yuv_data_2","yuv_data_3"};
      //初始化图像内存without stride************begin************
      for(int i=0; i<4; i++) {
          if(NULL == (vpcInMsg.collage.in_buffer[i] = (char*)malloc(vpcInMsg.collage.in_width*                                        vpcInMsg.collage.in_high*3/2)))
          {
              printf("in_buffer_image alloc failed!\n");
              for(int j=0; j<i; j++) {
                  free(vpcInMsg.collage.in_buffer[j]);
              }
              return ;
          }
          //打开图片至申请的内存中
          FILE * yuvimage = fopen(image_file[i],"rb");
          if(NULL == yuvimage)        {
              printf("PVC_TEST: yuv image open faild!");
              return ;
          }        else        {
              fread(vpcInMsg.collage.in_buffer[i], 1,vpcInMsg.collage.in_width*
                    vpcInMsg.collage.in_high*3/2,yuvimage);
              fclose(yuvimage);
              yuvimage = NULL;
          }
      }
  
      dvppApiCtlMsg.in = (void*)(&vpcInMsg);
      dvppApiCtlMsg.in_size = sizeof(vpc_in_msg);
      IDVPPAPI *pidvppapi = NULL;
      CreateDvppApi(pidvppapi);
      if(pidvppapi!=NULL)    {
          if(DvppCtl(pidvppapi,DVPP_CTL_VPC_PROC,&dvppApiCtlMsg)!= 0)        {
              printf("call dvppctl process faild!\n");
              DestroyDvppApi(pidvppapi);
              for(int i=0; i<4; i++) {
                  free(vpcInMsg.collage.in_buffer[i]);
              }
              return ;
          }
          DestroyDvppApi(pidvppapi);
          FILE * fp   = fopen("./out_collage_image_share","wb+");
          fwrite(vpcInMsg.collage.auto_out_buffer->getBuffer(),1,vpcInMsg.collage.in_width*vpcInMsg.collage.in_high*6,fp);
          fflush(fp);
          fclose(fp);
          fp=NULL;
          return ;
      }    else    {
          printf("pidvppapi is null!\n");
          return ;
      }
      for(int i=0; i<4; i++) {
          if(NULL != vpcInMsg.collage.in_buffer[i])        {
              free(vpcInMsg.collage.in_buffer[i]);
              vpcInMsg.collage.in_buffer[i] = NULL;
          }
      }

• VPCAPI调用

  IDVPPAPI *pidvppapi = NULL;
  CreateDvppApi(pidvppapi);
  if(pidvppapi!=NULL)
  {
   if(0 != DvppCtl(pidvppapi,DVPP_CTL_VPC_PROC,&dvppApiCtlMsg))
   {
    printf("call dvppctl process faild!\n");
    DestroyDvppApi(pidvppapi);
    return -1;
   }
  }
  else
  printf("pidvppapi is null!\n");
  DestroyDvppApi(pidvppapi);

• VPC Resize参数配置获取功能调用示例

  gXxxxx为配置参数

  dvppapi_ctl_msg dvppApiCtlMsg;
  vpc_in_msg vpcInMsg;
  resize_param_in_msg resize_in_param;
  resize_param_out_msg resize_out_param;
  resize_in_param.src_width = gWidth;
  resize_in_param.src_high = gHigh;
  resize_in_param.hmax = gHmax;
  resize_in_param.hmin = gHmin;
  resize_in_param.vmax = gVmax;
  resize_in_param.vmin = gVmin;
  resize_in_param.dest_width = floor(gHinc * (gHmax - gHmin + 1) + 0.5);
  resize_in_param.dest_high = floor(gVinc * (gVmax - gVmin + 1) + 0.5);
  dvppApiCtlMsg.in = (void *)(&resize_in_param);
  dvppApiCtlMsg.out = (void *)(&resize_out_param);
  IDVPPAPI *pidvppapi = NULL;
  CreateDvppApi(pidvppapi);
  if (0 != DvppCtl(pidvppapi, DVPP_CTL_TOOL_CASE_GET_RESIZE_PARAM, &dvppApiCtlMsg))
  {
    printf("call dvppctl process faild!\n");
    DestroyDvppApi(pidvppapi);
    return;
  }
  int bufferSize = 0;
  vpcInMsg.format = gFormat;
  vpcInMsg.cvdr_or_rdma = gcvdr_or_rdma;
  vpcInMsg.bitwidth = gBitwidth;
  vpcInMsg.rank = gRank;
  vpcInMsg.width = gWidth;
  vpcInMsg.high = gHigh;
  vpcInMsg.stride = gStride;
  vpcInMsg.hmax = resize_out_param.hmax;
  vpcInMsg.hmin = resize_out_param.hmin;
  vpcInMsg.vmax = resize_out_param.vmax;
  vpcInMsg.vmin = resize_out_param.vmin;
  vpcInMsg.vinc = resize_out_param.vinc;
  vpcInMsg.hinc = resize_out_param.hinc;

入参

CMDLIST输入为结构体，详细参数如图10-5、表10-27所示。

出参

暂无，其中输出图片在sum_out中的out_buffer中，用户可读取该内存获取图片。

输入图片格式与输出图片格式对应rank配置表请参见表10-27。

调用示例

/************************************************************************************************/
/*****用例说明：**********************************************************************************
此用例以一张1920x1088 yuv420 nv12图片作为输入
输入图片文件名： "file1_1920x1088_nv12.yuv"
对输入图片的操作：抠出5张子图，均缩放到224x224；
 ************************************************************************************************
 ************************************************************************************************/
int main()
{
    int ret = 0;
    //读取输入文件
    char image_file[128] = "file1_1920x1088_nv12.yuv";
    ifstream in_stream(image_file);
    if (!in_stream.is_open()) {
        printf("can not open %s.\n", image_file);
        return -1;
    }
    in_stream.seekg(0, ios::end);
    int file_len = in_stream.tellg();
    char* in_buffer = (char *)HIAI_DVPP_DMalloc(file_len);
    in_stream.seekg(0, ios::beg);
    in_stream.read(in_buffer, file_len);
    in_stream.close();
    //开始添加第一个image的配置
    IMAGE_CONFIG* image_config = (IMAGE_CONFIG*)malloc(sizeof(IMAGE_CONFIG));
    image_config->in_buffer.bare_buffer = in_buffer; //目前用到的都是非压缩图
    image_config->format = 0;
    image_config->rank = 1;//输入nv12输出也为nv12，rank填1
    image_config->bitwidth = 8;//目前用到的都是8bit一个单位的
    image_config->in_width = 1920;
    image_config->in_height = 1088;
    image_config->width_step = 1920;//这个值同宽
    //开始添加第一个抠图的配置,该例子抠图区域:(0,0),(511,511)围成的区域
    ROI_CONFIG* roi_config = &image_config->roi_config;
    //开始配置crop参数
    roi_config->crop_config.enable = 1; //注：当只要resize的时候，crop参数只要这个配置为0
    roi_config->crop_config.hmin = 0; 
    roi_config->crop_config.hmax = 511; 
    roi_config->crop_config.vmin = 0; 
    roi_config->crop_config.vmax = 511; 
    //开始配置输出通道参数
    roi_config->sum_out.enable = 1; //开启第一通道输出
    roi_config->sum_out.out_width = 224;
    roi_config->sum_out.out_height = 224;
    int out_buffer_size = AlignUp(224,128)*AlignUp(224,16)*3/2;
    roi_config->sum_out.out_buffer = (char*)HIAI_DVPP_DMalloc(out_buffer_size);
    ROI_CONFIG* last_roi = roi_config;
    //开始添加第2到第5个抠图的配置
    for (int i = 0 ; i < 4; i++) {
        ROI_CONFIG* roi_config = (ROI_CONFIG*)malloc(sizeof(ROI_CONFIG));
        //开始配置crop参数
        roi_config->crop_config.enable = 1; 
        roi_config->crop_config.hmin = 100*i; 
        roi_config->crop_config.hmax = 299 + 100*i; 
        roi_config->crop_config.vmin = 100*i; 
        roi_config->crop_config.vmax = 299 + 100*i; 
        //开始配置输出通道参数
        roi_config->sum_out.enable = 1; 
        roi_config->sum_out.out_width = 224;
        roi_config->sum_out.out_height = 224;
        out_buffer_size = AlignUp(224,128)*AlignUp(224,16)*3/2;
        roi_config->sum_out.out_buffer = (char*)HIAI_DVPP_DMalloc(out_buffer_size);
        roi_config->next = nullptr;
        last_roi->next = roi_config;
        last_roi = roi_config;
    }
    //开始调用dvpp的cmdlist接口    
    IDVPPAPI *pidvppapi = NULL;
    //无论后面调用多少次，createdvppapi只要一次调用就好
    ret = CreateDvppApi(pidvppapi);
    if (ret != 0) {
        printf("creat dvpp api faild!\n");
        return -1;
    }
    dvppapi_ctl_msg dvppApiCtlMsg;
    dvppApiCtlMsg.in = (void *)(image_config);
    dvppApiCtlMsg.in_size = sizeof(IMAGE_CONFIG);
    ret = DvppCtl(pidvppapi, DVPP_CTL_CMDLIST_PROC, &dvppApiCtlMsg);
    if (0 != ret) {
        printf("call cmdlist dvppctl process faild!\n");
    } else {
        printf("cmdlist success.\n");
    }
    ret += DestroyDvppApi(pidvppapi);    
    roi_config = image_config->roi_config.next;
    while (roi_config != nullptr) {
        ROI_CONFIG* next_roi = roi_config->next;
        UNMAP(roi_config->sum_out.out_buffer, out_buffer_size);
        free(roi_config);
        roi_config = next_roi;
    }
    UNMAP(image_config->roi_config.sum_out.out_buffer, out_buffer_size);
    free(image_config);
    UNMAP(in_buffer, file_len);
    return ret;    
}

功能

实现YUV420/YVU420图片数据的编码。

• VENC支持以下格式输入：

  YUV420 semi-planner NV12/NV21-8bit

• VENC输出格式为：

  H264 BP/MP/HP

  H265 MP

VENC性能指标

入参：venc_in_msg

出参

暂无。

调用示例

void TEST_3() //venc demo
{
    int read_file_size;
    int unit_file_size;
    FILE *fp = fopen(in_file_name, "rb");
    if (fp == NULL) {
        printf("open file: %s failed.\n", in_file_name);
        return;
    }
    printf("open yuv success \n");
    fseek(fp, 0L, SEEK_END);
    int file_size = ftell(fp);
    fseek(fp, 0L, SEEK_SET);

    venc_in_msg venc_msg;
    venc_msg.width = gWidth;
    venc_msg.height = gHigh;
    venc_msg.coding_type = gFormat;
    venc_msg.YUV_store_type = gBitwidth;
    venc_msg.output_data_queue = make_shared<AutoBuffer>();
    unit_file_size = gWidth * gHigh * 3 / 2 * MAX_FRAME_NUM_VENC; //单次文件大小为16帧
    dvppapi_ctl_msg dvppApiCtlMsg;
    dvppApiCtlMsg.in = (void *)(&venc_msg);
    dvppApiCtlMsg.in_size = sizeof(venc_in_msg);
    IDVPPAPI *pidvppapi = NULL;
    CreateDvppApi(pidvppapi);
    char out_filename[] = "venc.bin";
    FILE *outputBufferFile;
    outputBufferFile = fopen (out_filename, "wb+");

    do{
        read_file_size = file_size>unit_file_size? unit_file_size:file_size; //每次读取文件大小不能超过16帧
        venc_msg.input_data = (char *)malloc(read_file_size);
        int read_len = fread(venc_msg.input_data, 1, read_file_size, fp);
        printf("file size is %d,read len is %d.\n", read_file_size, read_len);
        venc_msg.input_data_size = read_len;        

        if (pidvppapi != NULL) {
            if (DvppCtl(pidvppapi, DVPP_CTL_VENC_PROC, &dvppApiCtlMsg) != 0) {
                printf("call dvppctl process faild!\n");
                DestroyDvppApi(pidvppapi);
                fclose(fp);
                fclose(outputBufferFile);
                return;
            }
            if (venc_msg.output_data_queue->getBufferSize() > 100) { //防止编码结果只含有头部信息
                char* out_buf = venc_msg.output_data_queue->getBuffer();
                int out_buf_size = venc_msg.output_data_queue->getBufferSize();
                int write_size = fwrite(out_buf, 1, out_buf_size, outputBufferFile);
                fflush(outputBufferFile);               
            } else {
                printf("venc output data is too small : %d \n", venc_msg.output_data_queue->getBufferSize());
            }

        } else {
            printf("pidvppapi is null!\n");
        }

        if (venc_msg.input_data != NULL) {
            free(venc_msg.input_data);
            venc_msg.input_data = NULL;
        }

        file_size = file_size - unit_file_size;
    } while (file_size > 0);

    DestroyDvppApi(pidvppapi);
    fclose(outputBufferFile);
    fclose(fp);
    return;
}