C++样例

样例一

函数原型：

APP_ERROR SendProtobuf(const std::string& streamName, int inPluginId, std::vector<MxstProtobufIn>& protoVec);

• C++版 MxTools.MxpiVisionLists使用样例（MxpiVisionList.cpp）

  #include <string.h>
  #include "MxBase/Log/Log.h"
  #include "MxStream/StreamManager/MxStreamManager.h"
  #include "MxTools/Proto/MxpiDataType.pb.h"
  
  APP_ERROR ReadFile(const std::string& filePath, MxStream::MxstDataInput& dataBuffer)
  {
      char c[PATH_MAX + 1] = { 0x00 };
      size_t count = filePath.copy(c, PATH_MAX + 1);
      if (count != filePath.length()) {
          LogError << "Failed to strcpy " << c;
          return APP_ERR_COMM_FAILURE;
      }
  
      char path[PATH_MAX + 1] = { 0x00 };
      if ((strlen(c) > PATH_MAX) || (realpath(c, path) == nullptr)) {
          LogError << "Failed to get image path(" << filePath << ").";
          return APP_ERR_COMM_NO_EXIST;
      }
      FILE *fp = fopen(path, "rb");
      if (fp == nullptr) {
          LogError << "Failed to open file";
          return APP_ERR_COMM_OPEN_FAIL;
      }
  
      fseek(fp, 0, SEEK_END);
      long fileSize = ftell(fp);
      fseek(fp, 0, SEEK_SET);
  
      if (fileSize > 0) {
          dataBuffer.dataSize = fileSize;
          dataBuffer.dataPtr = new (std::nothrow) uint32_t[fileSize];
          if (dataBuffer.dataPtr == nullptr) {
              LogError << "allocate memory with \"new uint32_t\" failed.";
              return APP_ERR_COMM_FAILURE;
          }
          uint32_t readRet = fread(dataBuffer.dataPtr, 1, fileSize, fp);
          if (readRet <= 0) {
              fclose(fp);
              return APP_ERR_COMM_READ_FAIL;
          }
          fclose(fp);
          return APP_ERR_OK;
      }
      fclose(fp);
      return APP_ERR_COMM_FAILURE;
  }
  std::string ReadPipelineConfig(std::string &pipelineConfigPath)
  {
      std::ifstream file(pipelineConfigPath.c_str(), std::ifstream::binary);
      if (!file) {
          LogError << pipelineConfigPath <<" file is not exists";
          return "";
      }
      file.seekg(0, std::ifstream::end);
      uint32_t fileSize = file.tellg();
      file.seekg(0);
      std::unique_ptr<char[]> data(new char[fileSize]);
      file.read(data.get(), fileSize);
      file.close();
      std::string pipelineConfig(data.get(), fileSize);
      return pipelineConfig;
  }
  int main(int argc, char*argv[])
  {
      MxStream::MxstDataInput dataInput;
      APP_ERROR ret = ReadFile("./test.yuv", dataInput);
      if (ret != APP_ERR_OK) {
          LogError << "Failed to read image file, ret = " << ret;
          return ret;
      }
  
      std::string pipelineConfigPath = "./Sample.pipeline";
      std::string pipelineConfig = ReadPipelineConfig(pipelineConfigPath);
      if (pipelineConfig == "") {
          return APP_ERR_COMM_INIT_FAIL;
      }
  
      auto *mxStreamManager = new MxStream::MxStreamManager();
      ret = mxStreamManager->InitManager();
      if (ret != APP_ERR_OK) {
          LogError << "Failed to init Stream manager, ret = " << ret << ".";
          return ret;
      }
      ret = mxStreamManager->CreateMultipleStreams(pipelineConfig);
      if (ret != APP_ERR_OK) {
          LogError << "Failed to create Stream, ret = " << ret << ".";
          return ret;
      }
  
      std::shared_ptr<MxTools::MxpiVisionList> objectList = std::make_shared<MxTools::MxpiVisionList>();
      MxTools::MxpiVision* MxpiVision = objectList->add_visionvec();
      MxTools::MxpiVisionInfo *visioninfo =  MxpiVision->mutable_visioninfo();
      visioninfo->set_format(12);
      visioninfo->set_width(416);
      visioninfo->set_height(416);
      visioninfo->set_widthaligned(416);
      visioninfo->set_heightaligned(416);
      MxTools::MxpiVisionData *visiondata =  MxpiVision->mutable_visiondata();
      visiondata->set_dataptr((uint64_t)dataInput.dataPtr);
      visiondata->set_datasize(dataInput.dataSize);
      visiondata->set_memtype(MxTools::MXPI_MEMORY_HOST_NEW);
      MxStream::MxstProtobufIn dataBuffer;
      dataBuffer.key = "appsrc0";
      dataBuffer.messagePtr = std::static_pointer_cast<google::protobuf::Message>(objectList);
      std::vector<MxStream::MxstProtobufIn> dataBufferVec;
      dataBufferVec.push_back(dataBuffer);
  
      std::string streamName = "classification";
      int inPluginId = 0;
      std::vector<std::string> keyVec;
      keyVec.push_back(dataBuffer.key);
      ret = mxStreamManager->SendProtobuf(streamName, inPluginId, dataBufferVec);
      std::vector<MxStream::MxstProtobufOut> output = mxStreamManager->GetProtobuf(streamName, inPluginId, keyVec);
      if (output.size() == 0) {
          LogError << "output size is 0";
  	return APP_ERR_ACL_FAILURE;		
      }
      if (output[0].errorCode != APP_ERR_OK) {
          LogError << "GetProtobuf error. errorCode=" << output[0].errorCode;
          return output[0].errorCode;
      }
      LogInfo << "errorCode=" << output[0].errorCode;
      LogInfo << "key=" << output[0].messageName;
      LogInfo << "value=" << output[0].messagePtr.get()->DebugString();
  
      mxStreamManager->DestroyAllStreams();
      delete mxStreamManager;
      mxStreamManager = nullptr;
      return 0;
  }

样例二

函数原型：

APP_ERROR SendProtobuf(const std::string& streamName, const std::string& elementName, std::vector<MxstProtobufIn>& protoVec);

std::string elementName = "appsrc0"
APP_ERROR ret = mxStreamManager->SendProtobuf(streamName, elementName, mxstProtobufInVec);
if (ret != APP_ERR_OK) {
    LogError << GetError(ret) << "SendProtobuf failed.";
    return ret;
}
std::vector<std::string> keys = {"appsrc0"};
std::vector<MxStream::MxstProtobufOut> mxstProtobufOutVec =
        mxStreamManager->GetProtobuf(streamName, outPluginId, keys);
for (uint32_t i = 0; i < mxstProtobufOutVec.size(); i++) {
    auto mxstProtobufOut = mxstProtobufOutVec[i];
    if (mxstProtobufOut.errorCode != APP_ERR_OK) {
        LogError << GetError(mxstProtobufOut.errorCode) << "GetProtobuf failed";
        return mxstProtobufOut.errorCode;
    }
    LogInfo << "result:" << mxstProtobufOut.messagePtr->DebugString();
}