clean code

mindspore/ccsrc/minddata/dataset/include/dataset/text.h

@@ -214,7 +214,8 @@ class SentencePieceVocab {
   ///     // Save vocab model to local
   ///     vocab->SaveModel(&vocab, datasets_root_path_ + "/test_sentencepiece", "m.model");
   /// \endcode
-  static Status SaveModel(const std::shared_ptr<SentencePieceVocab> *vocab, std::string path, std::string filename);
+  static Status SaveModel(const std::shared_ptr<SentencePieceVocab> *vocab, const std::string path,
+                          std::string filename);
 
   /// \brief Constructor.
   SentencePieceVocab();

mindspore/ccsrc/minddata/dataset/kernels/image/dvpp/utils/DvppCommon.cc

@@ -19,10 +19,10 @@
 #include "DvppCommon.h"
 #include "CommonDataType.h"
 
-static auto g_resizeConfigDeleter = [](acldvppResizeConfig *p) { acldvppDestroyResizeConfig(p); };
-static auto g_picDescDeleter = [](acldvppPicDesc *picDesc) { acldvppDestroyPicDesc(picDesc); };
-static auto g_roiConfigDeleter = [](acldvppRoiConfig *p) { acldvppDestroyRoiConfig(p); };
-static auto g_jpegeConfigDeleter = [](acldvppJpegeConfig *p) { acldvppDestroyJpegeConfig(p); };
+const static auto g_resizeConfigDeleter = [](acldvppResizeConfig *p) { (void)acldvppDestroyResizeConfig(p); };
+const static auto g_picDescDeleter = [](acldvppPicDesc *picDesc) { (void)acldvppDestroyPicDesc(picDesc); };
+const static auto g_roiConfigDeleter = [](acldvppRoiConfig *p) { (void)acldvppDestroyRoiConfig(p); };
+const static auto g_jpegeConfigDeleter = [](acldvppJpegeConfig *p) { (void)acldvppDestroyJpegeConfig(p); };
 
 DvppCommon::DvppCommon(aclrtContext dvppContext, aclrtStream dvppStream)
     : dvppContext_(dvppContext), dvppStream_(dvppStream) {}
@@ -43,7 +43,7 @@ APP_ERROR DvppCommon::Init(void) {
   APP_ERROR ret = acldvppCreateChannel(dvppChannelDesc_);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to create dvpp channel: " << GetAppErrCodeInfo(ret) << ".";
-    acldvppDestroyChannelDesc(dvppChannelDesc_);
+    (void)acldvppDestroyChannelDesc(dvppChannelDesc_);
     dvppChannelDesc_ = nullptr;
     return ret;
   }
@@ -157,7 +157,7 @@ APP_ERROR DvppCommon::DestroyResource() {
     if (ret != APP_ERR_OK) {
       MS_LOG(ERROR) << "Failed to destroy dvpp channel, ret = " << ret;
     }
-    aclvdecDestroyChannelDesc(vdecChannelDesc_);
+    (void)aclvdecDestroyChannelDesc(vdecChannelDesc_);
     vdecChannelDesc_ = nullptr;
   }
   return ret;
@@ -292,7 +292,7 @@ APP_ERROR DvppCommon::GetVpcOutputStrideSize(uint32_t width, uint32_t height, ac
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with Init
  */
-APP_ERROR DvppCommon::VpcResize(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize,
+APP_ERROR DvppCommon::VpcResize(const DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize,
                                 VpcProcessType processType) {
   // Return special error code when the DvppCommon object is initialized with InitVdec
   if (isVdec_) {
@@ -343,7 +343,7 @@ APP_ERROR DvppCommon::VpcResize(DvppDataInfo &input, DvppDataInfo &output, bool
  * @param: picsDesc specifies the picture description information to be set
  * @return: APP_ERR_OK if success, other values if failure
  */
-APP_ERROR DvppCommon::SetDvppPicDescData(const DvppDataInfo &dataInfo, acldvppPicDesc &picDesc) {
+APP_ERROR DvppCommon::SetDvppPicDescData(const DvppDataInfo &dataInfo, acldvppPicDesc &picDesc) const {
   APP_ERROR ret = acldvppSetPicDescData(&picDesc, dataInfo.data);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to set data for dvpp picture description, ret = " << ret << ".";
@@ -391,7 +391,7 @@ APP_ERROR DvppCommon::SetDvppPicDescData(const DvppDataInfo &dataInfo, acldvppPi
  * @param: output specifies the output image information
  * @return: APP_ERR_OK if success, other values if failure
  */
-APP_ERROR DvppCommon::CheckResizeParams(const DvppDataInfo &input, const DvppDataInfo &output) {
+APP_ERROR DvppCommon::CheckResizeParams(const DvppDataInfo &input, const DvppDataInfo &output) const {
   if (output.format != PIXEL_FORMAT_YUV_SEMIPLANAR_420 && output.format != PIXEL_FORMAT_YVU_SEMIPLANAR_420 &&
       output.format != PIXEL_FORMAT_RGB_888) {
     MS_LOG(ERROR) << "Output format[" << output.format << "] for VPC is not supported, only NV12 or NV21 or RGB888.";
@@ -456,8 +456,9 @@ APP_ERROR DvppCommon::ResizeProcess(acldvppPicDesc &inputDesc, acldvppPicDesc &o
  * @attention: If the width and height of the crop area are different from those of the
  *             paste area, the image is scaled again
  */
-APP_ERROR DvppCommon::ResizeWithPadding(acldvppPicDesc &inputDesc, acldvppPicDesc &outputDesc, CropRoiConfig &cropRoi,
-                                        CropRoiConfig &pasteRoi, bool withSynchronize) {
+APP_ERROR DvppCommon::ResizeWithPadding(acldvppPicDesc &inputDesc, acldvppPicDesc &outputDesc,
+                                        const CropRoiConfig &cropRoi, const CropRoiConfig &pasteRoi,
+                                        bool withSynchronize) {
   acldvppRoiConfig *cropRoiCfg = acldvppCreateRoiConfig(cropRoi.left, cropRoi.right, cropRoi.up, cropRoi.down);
   if (cropRoiCfg == nullptr) {
     MS_LOG(ERROR) << "Failed to create dvpp roi config for corp area.";
@@ -498,7 +499,7 @@ APP_ERROR DvppCommon::ResizeWithPadding(acldvppPicDesc &inputDesc, acldvppPicDes
  * @return: APP_ERR_OK if success, other values if failure
  */
 void DvppCommon::GetCropRoi(const DvppDataInfo &input, const DvppDataInfo &output, VpcProcessType processType,
-                            CropRoiConfig &cropRoi) {
+                            CropRoiConfig &cropRoi) const {
   // When processType is not VPC_PT_FILL, crop area is the whole input image
   if (processType != VPC_PT_FILL) {
     cropRoi.right = CONVERT_TO_ODD(input.width - ODD_NUM_1);
@@ -520,14 +521,14 @@ void DvppCommon::GetCropRoi(const DvppDataInfo &input, const DvppDataInfo &outpu
     cropRoi.left = 0;
     cropRoi.right = CONVERT_TO_ODD(input.width - ODD_NUM_1);
     cropRoi.up = CONVERT_TO_EVEN(static_cast<uint32_t>((input.height - output.height * resizeRatio) / halfValue));
-    cropRoi.down = CONVERT_TO_ODD(input.height - cropRoi.up - ODD_NUM_1);
+    cropRoi.down = CONVERT_TO_ODD((input.height - cropRoi.up) - ODD_NUM_1);
     return;
   }
 
   cropRoi.up = 0;
   cropRoi.down = CONVERT_TO_ODD(input.height - ODD_NUM_1);
   cropRoi.left = CONVERT_TO_EVEN(static_cast<uint32_t>((input.width - output.width * resizeRatio) / halfValue));
-  cropRoi.right = CONVERT_TO_ODD(input.width - cropRoi.left - ODD_NUM_1);
+  cropRoi.right = CONVERT_TO_ODD((input.width - cropRoi.left) - ODD_NUM_1);
   return;
 }
 
@@ -540,7 +541,7 @@ void DvppCommon::GetCropRoi(const DvppDataInfo &input, const DvppDataInfo &outpu
  * @return: APP_ERR_OK if success, other values if failure
  */
 void DvppCommon::GetPasteRoi(const DvppDataInfo &input, const DvppDataInfo &output, VpcProcessType processType,
-                             CropRoiConfig &pasteRoi) {
+                             CropRoiConfig &pasteRoi) const {
   if (processType == VPC_PT_FILL) {
     pasteRoi.right = CONVERT_TO_ODD(output.width - ODD_NUM_1);
     pasteRoi.down = CONVERT_TO_ODD(output.height - ODD_NUM_1);
@@ -569,13 +570,13 @@ void DvppCommon::GetPasteRoi(const DvppDataInfo &input, const DvppDataInfo &outp
   if (widthRatioLarger) {
     pasteRoi.left = 0;
     pasteRoi.right = output.width - ODD_NUM_1;
-    pasteRoi.up = (output.height - (input.height / resizeRatio)) / halfValue;
-    pasteRoi.down = output.height - pasteRoi.up - ODD_NUM_1;
+    pasteRoi.up = static_cast<uint32_t>((output.height - (input.height / resizeRatio)) / halfValue);
+    pasteRoi.down = (output.height - pasteRoi.up) - ODD_NUM_1;
   } else {
     pasteRoi.up = 0;
     pasteRoi.down = output.height - ODD_NUM_1;
-    pasteRoi.left = (output.width - (input.width / resizeRatio)) / halfValue;
-    pasteRoi.right = output.width - pasteRoi.left - ODD_NUM_1;
+    pasteRoi.left = static_cast<uint32_t>((output.width - (input.width / resizeRatio)) / halfValue);
+    pasteRoi.right = (output.width - pasteRoi.left) - ODD_NUM_1;
   }
 
   // The left must be even and align to 16, up must be even, right and down must be odd which is required by acl
@@ -595,7 +596,7 @@ void DvppCommon::GetPasteRoi(const DvppDataInfo &input, const DvppDataInfo &outp
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with Init
  */
-APP_ERROR DvppCommon::CombineResizeProcess(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize,
+APP_ERROR DvppCommon::CombineResizeProcess(DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize,
                                            VpcProcessType processType) {
   // Return special error code when the DvppCommon object is initialized with InitVdec
   if (isVdec_) {
@@ -638,7 +639,7 @@ APP_ERROR DvppCommon::CombineResizeProcess(DvppDataInfo &input, DvppDataInfo &ou
     return ret;
   }
 
-  aclrtMemset(resizedImage_->data, resizedImage_->dataSize, YUV_GREYER_VALUE, resizedImage_->dataSize);
+  (void)aclrtMemset(resizedImage_->data, resizedImage_->dataSize, YUV_GREYER_VALUE, resizedImage_->dataSize);
   resizedImage_->frameId = input.frameId;
   ret = VpcResize(input, *resizedImage_, withSynchronize, processType);
   if (ret != APP_ERR_OK) {
@@ -686,7 +687,7 @@ APP_ERROR DvppCommon::VpcCrop(const DvppCropInputInfo &cropInput, const DvppData
  * @param: input specifies the image information and the information about the area to be cropped
  * @return: APP_ERR_OK if success, other values if failure
  */
-APP_ERROR DvppCommon::CheckCropParams(const DvppCropInputInfo &input) {
+APP_ERROR DvppCommon::CheckCropParams(const DvppCropInputInfo &input) const {
   APP_ERROR ret;
   uint32_t payloadSize;
   ret = GetVpcDataSize(input.dataInfo.widthStride, input.dataInfo.heightStride, PIXEL_FORMAT_YUV_SEMIPLANAR_420,
@@ -708,8 +709,8 @@ APP_ERROR DvppCommon::CheckCropParams(const DvppCropInputInfo &input) {
   }
 
   // Calculate crop width and height according to the input location
-  uint32_t cropWidth = input.roi.right - input.roi.left + ODD_NUM_1;
-  uint32_t cropHeight = input.roi.down - input.roi.up + ODD_NUM_1;
+  uint32_t cropWidth = (input.roi.right - input.roi.left) + ODD_NUM_1;
+  uint32_t cropHeight = (input.roi.down - input.roi.up) + ODD_NUM_1;
   if ((cropWidth < MIN_CROP_WIDTH) || (cropHeight < MIN_CROP_HEIGHT)) {
     MS_LOG(ERROR) << "Crop area width:" << cropWidth << " need to be larger than 10 and height:" << cropHeight
                   << " need to be larger than 6.";
@@ -774,7 +775,7 @@ APP_ERROR DvppCommon::CropProcess(acldvppPicDesc &inputDesc, acldvppPicDesc &out
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with Init
  */
-APP_ERROR DvppCommon::CombineCropProcess(DvppCropInputInfo &input, DvppDataInfo &output, bool withSynchronize) {
+APP_ERROR DvppCommon::CombineCropProcess(DvppCropInputInfo &input, const DvppDataInfo &output, bool withSynchronize) {
   // Return special error code when the DvppCommon object is initialized with InitVdec
   if (isVdec_) {
     MS_LOG(ERROR) << "CombineCropProcess cannot be called by the DvppCommon object which is initialized with InitVdec.";
@@ -831,7 +832,7 @@ APP_ERROR DvppCommon::CombineCropProcess(DvppCropInputInfo &input, DvppDataInfo
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with Init
  */
-APP_ERROR DvppCommon::JpegDecode(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize) {
+APP_ERROR DvppCommon::JpegDecode(const DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize) {
   // Return special error code when the DvppCommon object is initialized with InitVdec
   if (isVdec_) {
     MS_LOG(ERROR) << "JpegDecode cannot be called by the DvppCommon object which is initialized with InitVdec.";
@@ -869,7 +870,7 @@ APP_ERROR DvppCommon::JpegDecode(DvppDataInfo &input, DvppDataInfo &output, bool
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with Init
  */
-APP_ERROR DvppCommon::PngDecode(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize) {
+APP_ERROR DvppCommon::PngDecode(const DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize) {
   // Return special error code when the DvppCommon object is initialized with InitVdec
   if (isVdec_) {
     MS_LOG(ERROR) << "PngDecode cannot be called by the DvppCommon object which is initialized with InitVdec.";
@@ -1050,8 +1051,8 @@ APP_ERROR DvppCommon::CombineJpegdProcess(const RawData &imageInfo, acldvppPixel
   // Member variable of inputImage_, uint8_t *data will be on device
   inputImage_ = std::make_shared<DvppDataInfo>();
   inputImage_->format = format;
-  APP_ERROR ret =
-    GetJpegImageInfo(imageInfo.data, imageInfo.lenOfByte, inputImage_->width, inputImage_->height, components);
+  APP_ERROR ret = GetJpegImageInfo(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), inputImage_->width,
+                                   inputImage_->height, components);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get input image info, ret = " << ret << ".";
     return ret;
@@ -1059,7 +1060,7 @@ APP_ERROR DvppCommon::CombineJpegdProcess(const RawData &imageInfo, acldvppPixel
 
   // Get the buffer size(On device) of decode output according to the input data and output format
   uint32_t outBuffSize;
-  ret = GetJpegDecodeDataSize(imageInfo.data, imageInfo.lenOfByte, format, outBuffSize);
+  ret = GetJpegDecodeDataSize(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), format, outBuffSize);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get size of decode output buffer, ret = " << ret << ".";
     return ret;
@@ -1101,8 +1102,8 @@ APP_ERROR DvppCommon::CombineJpegdProcess(const RawData &imageInfo, acldvppPixel
   return APP_ERR_OK;
 }
 
-APP_ERROR DvppCommon::SinkCombineJpegdProcess(std::shared_ptr<DvppDataInfo> &input,
-                                              std::shared_ptr<DvppDataInfo> &output, bool withSynchronize) {
+APP_ERROR DvppCommon::SinkCombineJpegdProcess(const std::shared_ptr<DvppDataInfo> &input,
+                                              const std::shared_ptr<DvppDataInfo> &output, bool withSynchronize) {
   // Both input and output are locate on device, so we must release them if fail in decode
   APP_ERROR ret = JpegDecode(*input, *output, withSynchronize);
   if (ret != APP_ERR_OK) {
@@ -1116,8 +1117,8 @@ APP_ERROR DvppCommon::SinkCombineJpegdProcess(std::shared_ptr<DvppDataInfo> &inp
   return APP_ERR_OK;
 }
 
-APP_ERROR DvppCommon::SinkCombinePngdProcess(std::shared_ptr<DvppDataInfo> &input,
-                                             std::shared_ptr<DvppDataInfo> &output, bool withSynchronize) {
+APP_ERROR DvppCommon::SinkCombinePngdProcess(const std::shared_ptr<DvppDataInfo> &input,
+                                             const std::shared_ptr<DvppDataInfo> &output, bool withSynchronize) {
   // Both input and output are locate on device, so we must release them if fail in decode
   APP_ERROR ret = PngDecode(*input, *output, withSynchronize);
   if (ret != APP_ERR_OK) {
@@ -1150,8 +1151,8 @@ APP_ERROR DvppCommon::CombinePngdProcess(const RawData &imageInfo, acldvppPixelF
   int32_t components;
   inputImage_ = std::make_shared<DvppDataInfo>();
   inputImage_->format = format;
-  APP_ERROR ret =
-    GetPngImageInfo(imageInfo.data, imageInfo.lenOfByte, inputImage_->width, inputImage_->height, components);
+  APP_ERROR ret = GetPngImageInfo(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), inputImage_->width,
+                                  inputImage_->height, components);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get input image info, ret = " << ret << ".";
     return ret;
@@ -1159,7 +1160,7 @@ APP_ERROR DvppCommon::CombinePngdProcess(const RawData &imageInfo, acldvppPixelF
 
   // Get the buffer size of decode output according to the input data and output format
   uint32_t outBuffSize;
-  ret = GetPngDecodeDataSize(imageInfo.data, imageInfo.lenOfByte, format, outBuffSize);
+  ret = GetPngDecodeDataSize(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), format, outBuffSize);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get size of decode output buffer, ret = " << ret << ".";
     return ret;
@@ -1206,7 +1207,7 @@ APP_ERROR DvppCommon::CombinePngdProcess(const RawData &imageInfo, acldvppPixelF
  * @return: APP_ERR_OK if success, other values if failure
  */
 APP_ERROR DvppCommon::TransferYuvDataH2D(const DvppDataInfo &imageinfo) {
-  if (imageinfo.dataSize <= 0) {
+  if (imageinfo.dataSize == 0) {
     MS_LOG(ERROR) << "The input buffer size on host should not be empty.";
     return APP_ERR_COMM_INVALID_PARAM;
   }
@@ -1221,12 +1222,14 @@ APP_ERROR DvppCommon::TransferYuvDataH2D(const DvppDataInfo &imageinfo) {
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to copy " << imageinfo.dataSize << " bytes from host to device, ret = " << ret << ".";
     RELEASE_DVPP_DATA(device_ptr);
+    device_ptr = nullptr;
     return ret;
   }
   ret = aclrtSynchronizeStream(dvppStream_);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to synchronize stream, ret = " << ret << ".";
     RELEASE_DVPP_DATA(device_ptr);
+    device_ptr = nullptr;
     return ret;
   }
   /* Important!!! decodedImage_ speifies the image in decoded format(RGB OR YUV)
@@ -1251,7 +1254,7 @@ APP_ERROR DvppCommon::TransferYuvDataH2D(const DvppDataInfo &imageinfo) {
  */
 APP_ERROR DvppCommon::TransferImageH2D(const RawData &imageInfo, const std::shared_ptr<DvppDataInfo> &jpegInput) {
   // Check image buffer size validity
-  if (imageInfo.lenOfByte <= 0) {
+  if (imageInfo.lenOfByte == 0) {
     MS_LOG(ERROR) << "The input buffer size on host should not be empty.";
     return APP_ERR_COMM_INVALID_PARAM;
   }
@@ -1280,7 +1283,7 @@ APP_ERROR DvppCommon::TransferImageH2D(const RawData &imageInfo, const std::shar
     return ret;
   }
   jpegInput->data = inDevBuff;
-  jpegInput->dataSize = imageInfo.lenOfByte;
+  jpegInput->dataSize = static_cast<uint32_t>(imageInfo.lenOfByte);
   return APP_ERR_OK;
 }
 
@@ -1304,7 +1307,8 @@ APP_ERROR DvppCommon::SinkImageH2D(const RawData &imageInfo, acldvppPixelFormat
   // Member variable of inputImage_, uint8_t *data will be on device
   inputImage_ = std::make_shared<DvppDataInfo>();
   inputImage_->format = format;
-  ret = GetJpegImageInfo(imageInfo.data, imageInfo.lenOfByte, inputImage_->width, inputImage_->height, components);
+  ret = GetJpegImageInfo(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), inputImage_->width,
+                         inputImage_->height, components);
 
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get input image info, ret = " << ret << ".";
@@ -1314,7 +1318,7 @@ APP_ERROR DvppCommon::SinkImageH2D(const RawData &imageInfo, acldvppPixelFormat
   // Get the buffer size(On device) of decode output according to the input data and output format
   uint32_t outBufferSize;
 
-  ret = GetJpegDecodeDataSize(imageInfo.data, imageInfo.lenOfByte, format, outBufferSize);
+  ret = GetJpegDecodeDataSize(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), format, outBufferSize);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get size of decode output buffer, ret = " << ret << ".";
     return ret;
@@ -1363,7 +1367,8 @@ APP_ERROR DvppCommon::SinkImageH2D(const RawData &imageInfo) {
   acldvppPixelFormat format = PIXEL_FORMAT_RGB_888;
   inputImage_->format = format;
 
-  ret = GetPngImageInfo(imageInfo.data, imageInfo.lenOfByte, inputImage_->width, inputImage_->height, components);
+  ret = GetPngImageInfo(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), inputImage_->width,
+                        inputImage_->height, components);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get input image info, ret = " << ret << ".";
     return ret;
@@ -1372,7 +1377,7 @@ APP_ERROR DvppCommon::SinkImageH2D(const RawData &imageInfo) {
   // Get the buffer size of decode output according to the input data and output format
   uint32_t outBuffSize;
 
-  ret = GetPngDecodeDataSize(imageInfo.data, imageInfo.lenOfByte, format, outBuffSize);
+  ret = GetPngDecodeDataSize(imageInfo.data, static_cast<uint32_t>(imageInfo.lenOfByte), format, outBuffSize);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to get size of decode output buffer, ret = " << ret << ".";
     return ret;
@@ -1408,7 +1413,7 @@ APP_ERROR DvppCommon::SinkImageH2D(const RawData &imageInfo) {
  * @param: data specifies the information about the video stream
  * @return: APP_ERR_OK if success, other values if failure
  */
-APP_ERROR DvppCommon::CreateStreamDesc(std::shared_ptr<DvppDataInfo> data) {
+APP_ERROR DvppCommon::CreateStreamDesc(const std::shared_ptr<DvppDataInfo> &data) {
   // Malloc input device memory which need to be released in vdec callback function
   void *modelInBuff = nullptr;
   APP_ERROR ret = acldvppMalloc(&modelInBuff, data->dataSize);
@@ -1422,7 +1427,7 @@ APP_ERROR DvppCommon::CreateStreamDesc(std::shared_ptr<DvppDataInfo> data) {
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to copy memory with " << data->dataSize << " bytes from host to device, ret = " << ret
                   << ".";
-    acldvppFree(modelInBuff);
+    (void)acldvppFree(modelInBuff);
     modelInBuff = nullptr;
     return APP_ERR_ACL_FAILURE;
   }
@@ -1454,7 +1459,7 @@ APP_ERROR DvppCommon::CreateStreamDesc(std::shared_ptr<DvppDataInfo> data) {
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with InitVdec
  */
-APP_ERROR DvppCommon::CombineVdecProcess(std::shared_ptr<DvppDataInfo> data, void *userData) {
+APP_ERROR DvppCommon::CombineVdecProcess(const std::shared_ptr<DvppDataInfo> data, void *userData) {
   // Return special error code when the DvppCommon object is not initialized with InitVdec
   if (!isVdec_) {
     MS_LOG(ERROR)
@@ -1488,8 +1493,8 @@ APP_ERROR DvppCommon::CombineVdecProcess(std::shared_ptr<DvppDataInfo> data, voi
   }
 
   DvppDataInfo dataInfo;
-  dataInfo.width = vdecConfig_.inputWidth;
-  dataInfo.height = vdecConfig_.inputHeight;
+  dataInfo.width = static_cast<uint32_t>(vdecConfig_.inputWidth);
+  dataInfo.height = static_cast<uint32_t>(vdecConfig_.inputHeight);
   dataInfo.format = vdecConfig_.outFormat;
   dataInfo.dataSize = dataSize;
   dataInfo.data = static_cast<uint8_t *>(picOutBufferDev);
@@ -1521,10 +1526,10 @@ APP_ERROR DvppCommon::VdecSendEosFrame() const {
   }
 
   // set eos for eos stream desc
-  APP_ERROR ret = acldvppSetStreamDescEos(eosStreamDesc, true);
+  APP_ERROR ret = acldvppSetStreamDescEos(eosStreamDesc, 1);
   if (ret != ACL_ERROR_NONE) {
     MS_LOG(ERROR) << "Fail to set eos for stream desc, ret = " << ret << ".";
-    acldvppDestroyStreamDesc(eosStreamDesc);
+    (void)acldvppDestroyStreamDesc(eosStreamDesc);
     return ret;
   }
 
@@ -1532,7 +1537,7 @@ APP_ERROR DvppCommon::VdecSendEosFrame() const {
   ret = aclvdecSendFrame(vdecChannelDesc_, eosStreamDesc, nullptr, nullptr, nullptr);
   if (ret != ACL_ERROR_NONE) {
     MS_LOG(ERROR) << "Fail to send eos, ret = " << ret << ".";
-    acldvppDestroyStreamDesc(eosStreamDesc);
+    (void)acldvppDestroyStreamDesc(eosStreamDesc);
     return ret;
   }
 
@@ -1596,7 +1601,7 @@ APP_ERROR DvppCommon::GetVideoDecodeDataSize(uint32_t width, uint32_t height, ac
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with Init
  */
-APP_ERROR DvppCommon::JpegEncode(DvppDataInfo &input, DvppDataInfo &output, acldvppJpegeConfig *jpegeConfig,
+APP_ERROR DvppCommon::JpegEncode(const DvppDataInfo &input, DvppDataInfo &output, acldvppJpegeConfig *jpegeConfig,
                                  bool withSynchronize) {
   // Return special error code when the DvppCommon object is initialized with InitVdec
   if (isVdec_) {
@@ -1631,7 +1636,7 @@ APP_ERROR DvppCommon::JpegEncode(DvppDataInfo &input, DvppDataInfo &output, acld
  * @param: inputImage specifies the input image information
  * @return: APP_ERR_OK if success, other values if failure
  */
-APP_ERROR DvppCommon::GetJpegEncodeStrideSize(std::shared_ptr<DvppDataInfo> &inputImage) {
+APP_ERROR DvppCommon::GetJpegEncodeStrideSize(const std::shared_ptr<DvppDataInfo> &inputImage) {
   uint32_t inputWidth = inputImage->width;
   uint32_t inputHeight = inputImage->height;
   acldvppPixelFormat format = inputImage->format;
@@ -1670,7 +1675,8 @@ APP_ERROR DvppCommon::GetJpegEncodeStrideSize(std::shared_ptr<DvppDataInfo> &inp
  * @return: APP_ERR_OK if success, other values if failure
  * @attention: This function can be called only when the DvppCommon object is initialized with Init
  */
-APP_ERROR DvppCommon::GetJpegEncodeDataSize(DvppDataInfo &input, acldvppJpegeConfig *jpegeConfig, uint32_t &encSize) {
+APP_ERROR DvppCommon::GetJpegEncodeDataSize(const DvppDataInfo &input, const acldvppJpegeConfig *jpegeConfig,
+                                            uint32_t &encSize) {
   // Return special error code when the DvppCommon object is initialized with InitVdec
   if (isVdec_) {
     MS_LOG(ERROR)
@@ -1774,7 +1780,7 @@ APP_ERROR DvppCommon::CombineJpegeProcess(const RawData &imageInfo, uint32_t wid
   ret = acldvppMalloc((void **)&encodedImage_->data, encodedImage_->dataSize);
   if (ret != APP_ERR_OK) {
     MS_LOG(ERROR) << "Failed to malloc memory on dvpp, ret = " << ret << ".";
-    acldvppFree(inputImage_->data);
+    (void)acldvppFree(inputImage_->data);
     return ret;
   }
 
@@ -1782,8 +1788,8 @@ APP_ERROR DvppCommon::CombineJpegeProcess(const RawData &imageInfo, uint32_t wid
   ret = JpegEncode(*inputImage_, *encodedImage_, jpegeConfig_.get(), withSynchronize);
   if (ret != APP_ERR_OK) {
     // Release the output buffer when decode failed, otherwise release it after use
-    acldvppFree(inputImage_->data);
-    acldvppFree(encodedImage_->data);
+    (void)acldvppFree(inputImage_->data);
+    (void)acldvppFree(encodedImage_->data);
     return ret;
   }
   return APP_ERR_OK;

mindspore/ccsrc/minddata/dataset/kernels/image/dvpp/utils/DvppCommon.h

@@ -18,7 +18,6 @@
 
 #include "CommonDataType.h"
 #include "ErrorCode.h"
-#include "acl/ops/acl_dvpp.h"
 
 const int MODULUS_NUM_2 = 2;
 const uint32_t ODD_NUM_1 = 1;
@@ -140,7 +139,7 @@ class DvppCommon {
                                          uint32_t &decSize);
   static APP_ERROR GetPngDecodeDataSize(const void *data, uint32_t dataSize, acldvppPixelFormat format,
                                         uint32_t &decSize);
-  static APP_ERROR GetJpegEncodeStrideSize(std::shared_ptr<DvppDataInfo> &inputImage);
+  static APP_ERROR GetJpegEncodeStrideSize(const std::shared_ptr<DvppDataInfo> &inputImage);
   static APP_ERROR SetEncodeLevel(uint32_t level, acldvppJpegeConfig &jpegeConfig);
   static APP_ERROR GetVideoDecodeStrideSize(uint32_t width, uint32_t height, acldvppPixelFormat format,
                                             uint32_t &widthStride, uint32_t &heightStride);
@@ -148,31 +147,31 @@ class DvppCommon {
                                           uint32_t &vdecSize);
 
   // The following interfaces can be called only when the DvppCommon object is initialized with Init
-  APP_ERROR VpcResize(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize,
+  APP_ERROR VpcResize(const DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize,
                       VpcProcessType processType = VPC_PT_DEFAULT);
   APP_ERROR VpcCrop(const DvppCropInputInfo &cropInput, const DvppDataInfo &output, bool withSynchronize);
-  APP_ERROR JpegDecode(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize);
+  APP_ERROR JpegDecode(const DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize);
 
-  APP_ERROR PngDecode(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize);
+  APP_ERROR PngDecode(const DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize);
 
-  APP_ERROR JpegEncode(DvppDataInfo &input, DvppDataInfo &output, acldvppJpegeConfig *jpegeConfig,
+  APP_ERROR JpegEncode(const DvppDataInfo &input, DvppDataInfo &output, acldvppJpegeConfig *jpegeConfig,
                        bool withSynchronize);
 
-  APP_ERROR GetJpegEncodeDataSize(DvppDataInfo &input, acldvppJpegeConfig *jpegeConfig, uint32_t &encSize);
+  APP_ERROR GetJpegEncodeDataSize(const DvppDataInfo &input, const acldvppJpegeConfig *jpegeConfig, uint32_t &encSize);
 
   // These functions started with "Combine" encapsulate the DVPP process together, malloc DVPP memory,
   // transfer pictures from host to device, and then execute the DVPP operation.
   // The caller needs to pay attention to the release of the memory allocated in these functions.
   // You can call the ReleaseDvppBuffer function to release memory after use completely.
-  APP_ERROR CombineResizeProcess(DvppDataInfo &input, DvppDataInfo &output, bool withSynchronize,
+  APP_ERROR CombineResizeProcess(DvppDataInfo &input, const DvppDataInfo &output, bool withSynchronize,
                                  VpcProcessType processType = VPC_PT_DEFAULT);
-  APP_ERROR CombineCropProcess(DvppCropInputInfo &input, DvppDataInfo &output, bool withSynchronize);
+  APP_ERROR CombineCropProcess(DvppCropInputInfo &input, const DvppDataInfo &output, bool withSynchronize);
   APP_ERROR CombineJpegdProcess(const RawData &imageInfo, acldvppPixelFormat format, bool withSynchronize);
 
-  APP_ERROR SinkCombineJpegdProcess(std::shared_ptr<DvppDataInfo> &input, std::shared_ptr<DvppDataInfo> &output,
-                                    bool withSynchronize);
-  APP_ERROR SinkCombinePngdProcess(std::shared_ptr<DvppDataInfo> &input, std::shared_ptr<DvppDataInfo> &output,
-                                   bool withSynchronize);
+  APP_ERROR SinkCombineJpegdProcess(const std::shared_ptr<DvppDataInfo> &input,
+                                    const std::shared_ptr<DvppDataInfo> &output, bool withSynchronize);
+  APP_ERROR SinkCombinePngdProcess(const std::shared_ptr<DvppDataInfo> &input,
+                                   const std::shared_ptr<DvppDataInfo> &output, bool withSynchronize);
 
   APP_ERROR CombineJpegeProcess(const RawData &imageInfo, uint32_t width, uint32_t height, acldvppPixelFormat format,
                                 bool withSynchronize);
@@ -180,7 +179,7 @@ class DvppCommon {
   APP_ERROR CombinePngdProcess(const RawData &imageInfo, acldvppPixelFormat format, bool withSynchronize);
 
   // The following interface can be called only when the DvppCommon object is initialized with InitVdec
-  APP_ERROR CombineVdecProcess(std::shared_ptr<DvppDataInfo> data, void *userData);
+  APP_ERROR CombineVdecProcess(const std::shared_ptr<DvppDataInfo> data, void *userData);
 
   // Get the private member variables which are assigned in the interfaces which are started with "Combine"
   std::shared_ptr<DvppDataInfo> GetInputImage();
@@ -203,19 +202,19 @@ class DvppCommon {
   APP_ERROR VdecSendEosFrame() const;
 
  private:
-  APP_ERROR SetDvppPicDescData(const DvppDataInfo &dataInfo, acldvppPicDesc &picDesc);
+  APP_ERROR SetDvppPicDescData(const DvppDataInfo &dataInfo, acldvppPicDesc &picDesc) const;
   APP_ERROR ResizeProcess(acldvppPicDesc &inputDesc, acldvppPicDesc &outputDesc, bool withSynchronize);
-  APP_ERROR ResizeWithPadding(acldvppPicDesc &inputDesc, acldvppPicDesc &outputDesc, CropRoiConfig &cropRoi,
-                              CropRoiConfig &pasteRoi, bool withSynchronize);
+  APP_ERROR ResizeWithPadding(acldvppPicDesc &inputDesc, acldvppPicDesc &outputDesc, const CropRoiConfig &cropRoi,
+                              const CropRoiConfig &pasteRoi, bool withSynchronize);
   void GetCropRoi(const DvppDataInfo &input, const DvppDataInfo &output, VpcProcessType processType,
-                  CropRoiConfig &cropRoi);
+                  CropRoiConfig &cropRoi) const;
   void GetPasteRoi(const DvppDataInfo &input, const DvppDataInfo &output, VpcProcessType processType,
-                   CropRoiConfig &pasteRoi);
+                   CropRoiConfig &pasteRoi) const;
   APP_ERROR CropProcess(acldvppPicDesc &inputDesc, acldvppPicDesc &outputDesc, const CropRoiConfig &cropArea,
                         bool withSynchronize);
-  APP_ERROR CheckResizeParams(const DvppDataInfo &input, const DvppDataInfo &output);
-  APP_ERROR CheckCropParams(const DvppCropInputInfo &input);
-  APP_ERROR CreateStreamDesc(std::shared_ptr<DvppDataInfo> data);
+  APP_ERROR CheckResizeParams(const DvppDataInfo &input, const DvppDataInfo &output) const;
+  APP_ERROR CheckCropParams(const DvppCropInputInfo &input) const;
+  APP_ERROR CreateStreamDesc(const std::shared_ptr<DvppDataInfo> &data);
   APP_ERROR DestroyResource();
 
   std::shared_ptr<acldvppRoiConfig> cropAreaConfig_ = nullptr;

mindspore/ccsrc/minddata/dataset/kernels/image/dvpp/utils/ErrorCode.h

@@ -255,4 +255,4 @@ void CheckErrorCode(const int code, const std::string file, const std::string fu
 #define RtAssert(code) AssertErrorCode(code, __FILE__, __FUNCTION__, __LINE__);
 #define RtCheckError(code) CheckErrorCode(code, __FILE__, __FUNCTION__, __LINE__);
 
-#endif  // ERROR_CODE_H_
+#endif  // ERROR_CODE_H_

mindspore/ccsrc/minddata/dataset/text/sentence_piece_vocab.cc

@@ -88,7 +88,7 @@ Status SentencePieceVocab::BuildFromFile(const std::vector<std::string> &path_li
   return Status::OK();
 }
 
-Status SentencePieceVocab::SaveModel(const std::shared_ptr<SentencePieceVocab> *vocab, std::string path,
+Status SentencePieceVocab::SaveModel(const std::shared_ptr<SentencePieceVocab> *vocab, const std::string path,
                                      std::string filename) {
   if (vocab == nullptr) {
     RETURN_STATUS_UNEXPECTED("SentencePieceVocab::SaveModel: input vocab can not be null");

mindspore/ccsrc/minddata/dataset/text/vocab.cc

@@ -40,7 +40,7 @@ WordIdType Vocab::TokensToIds(const WordType &word) const {
 
 std::vector<WordIdType> Vocab::TokensToIds(const std::vector<WordType> &words) const {
   std::vector<WordIdType> ids;
-  std::transform(words.begin(), words.end(), std::back_inserter(ids), [this](auto w) { return TokensToIds(w); });
+  (void)std::transform(words.begin(), words.end(), std::back_inserter(ids), [this](auto w) { return TokensToIds(w); });
   return ids;
 }
 
@@ -63,13 +63,13 @@ std::vector<WordType> Vocab::IdsToTokens(const std::vector<WordIdType> &ids) {
     }
   }
   std::vector<WordType> words;
-  std::transform(ids.begin(), ids.end(), std::back_inserter(words), [this](auto i) { return IdsToTokens(i); });
+  (void)std::transform(ids.begin(), ids.end(), std::back_inserter(words), [this](auto i) { return IdsToTokens(i); });
   return words;
 }
 
 void Vocab::AppendWord(const std::string &word) {
   if (word2id_.find(word) == word2id_.end()) {
-    word2id_[word] = word2id_.size();
+    word2id_[word] = static_cast<WordIdType>(word2id_.size());
   }
 }
 
@@ -150,7 +150,7 @@ Status Vocab::BuildFromFile(const std::string &path, const std::string &delimite
   std::unordered_set<std::string> specials;
   // used to check that words in file don't contain any special token that already exists
   for (auto word : special_tokens) {
-    specials.insert(word);
+    (void)specials.insert(word);
   }
   WordIdType word_id = prepend_special ? static_cast<WordIdType>(special_tokens.size()) : 0;
   std::unordered_map<WordType, WordIdType> word2id;

mindspore/ccsrc/minddata/dataset/util/cond_var.cc

@@ -50,7 +50,7 @@ Status CondVar::WaitFor(std::unique_lock<std::mutex> *lck, int64_t duration) {
     if (svc_ != nullptr) {
       // If this cv registers with a global resource tracking, then wait unconditionally.
       auto f = [this]() -> bool { return this->Interrupted(); };
-      cv_.wait_for(*lck, std::chrono::milliseconds(duration), f);
+      (void)cv_.wait_for(*lck, std::chrono::milliseconds(duration), f);
       // If we are interrupted, override the return value if this is the master thread.
       // Master thread is being interrupted mostly because of some thread is reporting error.
       RETURN_IF_NOT_OK(Task::OverrideInterruptRc(this->GetInterruptStatus()));

mindspore/ccsrc/minddata/dataset/util/task.cc

@@ -111,6 +111,7 @@ Status Task::GetTaskErrorIfAny() const {
 Task::Task(const std::string &myName, const std::function<Status()> &f, int32_t operator_id)
     : my_name_(myName),
       operator_id_(operator_id),
+      thread_id_(-1),
       rc_(),
       fnc_obj_(f),
       task_group_(nullptr),

mindspore/ccsrc/minddata/mindrecord/io/shard_reader.cc

@@ -267,7 +267,7 @@ Status ShardReader::ExtendRandomFileStreams(const int n_new_consumers) {
                                  ", new n_consumers: " + std::to_string(n_consumer_ + n_new_consumers));
 
   for (int i = 0; i < n_new_consumers; i++) {
-    file_streams_random_.emplace_back(std::vector<std::shared_ptr<std::fstream>>());
+    (void)file_streams_random_.emplace_back(std::vector<std::shared_ptr<std::fstream>>());
   }
 
   for (const auto &file : file_paths_) {

mindspore/ccsrc/minddata/mindrecord/io/shard_writer.cc

@@ -62,7 +62,7 @@ Status ShardWriter::GetFullPathFromFileName(const std::vector<std::string> &path
     std::optional<std::string> whole_path = "";
     FileUtils::ConcatDirAndFileName(&realpath, &local_file_name, &whole_path);
 
-    file_paths_.emplace_back(whole_path.value());
+    (void)file_paths_.emplace_back(whole_path.value());
   }
   return Status::OK();
 }

mindspore/ccsrc/minddata/mindrecord/meta/shard_header.cc

@@ -382,7 +382,7 @@ std::string ShardHeader::SerializeShardAddress() {
   std::shared_ptr<std::string> fn_ptr;
   for (const auto &addr : shard_addresses_) {
     (void)GetFileName(addr, &fn_ptr);
-    j.emplace_back(*fn_ptr);
+    (void)j.emplace_back(*fn_ptr);
   }
   return j.dump();
 }

mindspore/lite/minddata/wrapper/MDToDApi.cc

@@ -88,7 +88,7 @@ std::vector<std::string> MDToDBuffToVector(MDToDBuff_t StrBuff) {
 
 extern "C"
 
-int MDToDApi_pathTest(const char* path) {
+int MDToDApi_pathTest(const char *path) {
   Path f(path);
   MS_LOG(INFO) << f.Exists() << f.IsDirectory() << f.ParentPath();
   // Print out the first few items in the directory