VPC Functions and Parameters

Input Parameter: resize_param_in_msg

Output Parameter: resize_param_out_msg

Input Parameter: vpc_in_msg

Calling Example

• Example of calling basic VPC functions:

  gXxxxx is a configuration parameter. Configuring the parameter and calling the VPC are two steps.

  Step 1: Use the DVPP_CTL_TOOL_CASE_GET_RESIZE_PARAM command word to call DvppCtl to obtain the configuration parameters. The input parameter of DvppCtl is resize_param_in_msg, and the output parameter is resize_param_out_msg. Use resize_param_in_msg to send the width and height of the original image, cropped area (hmax,hmin,vmax,vmin), and output width and height to the DVPP. The DVPP returns the regenerated cropped area (hmax,hmin,vmax,vmin) and resizing ratio (hinc,vinc) to the caller after calculation.

  Step 2: The caller transfers the parameters returned in step 1 to the DVPP by using vpc_in_msg, changes the DvppCtl command word to DVPP_CTL_VPC_PROC to obtain the processing result.

      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;

• Example of calling basic raw data 8K functions:

  Parameter settings:

      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;

• Example of calling basic raw data overlay functions:

      dvppapi_ctl_msg dvppApiCtlMsg;
      vpc_in_msg vpcInMsg;
      // Configures raw data overlay parameters.
      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>();
      // Initializes the image buffer.
      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 ;
      }
      // Opens the image and sends the data to the allocated buffer.
      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;
  }
  
      // Initializes the text buffer.
      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 ;
      }
  
      // Opens the text-based image and sends the data to the allocated memory.
      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;
      }

• Example of calling basic raw data stitching functions:

      dvppapi_ctl_msg dvppApiCtlMsg;
      vpc_in_msg vpcInMsg;
       // Configures raw data stitching parameters.
      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"};
      // Initializes the image buffer (without stride data)************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 ;
          }
         // Opens the image and sends the data to the allocated buffer.
          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;
          }
      }

• Example of calling the VPC API:

  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);

• Example of calling functions for configuring and obtaining VPC resizing parameters:

  gXxxxx is a configuration parameter.

  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;