Method body

plugins/wasmedge_stablediffusion/sd_func.cpp:209–252

}

Expect<uint32_t> SDConvert::body(const Runtime::CallingFrame &Frame,
                                 uint32_t ModelPathPtr, uint32_t ModelPathLen,
                                 uint32_t VaeModelPathPtr,
                                 uint32_t VaeModelPathLen,
                                 uint32_t OutputPathPtr, uint32_t OutputPathLen,
                                 uint32_t WType) {
  // Check memory instance from module.
  MEMINST_CHECK(MemInst, Frame, 0)

  // Check the input parameter value.
  MEM_SPAN_CHECK(ModelPathSpan, MemInst, char, ModelPathPtr, ModelPathLen,
                 "Failed when accessing the input model path memory."sv)
  MEM_SPAN_CHECK(VaeModelPathSpan, MemInst, char, VaeModelPathPtr,
                 VaeModelPathLen,
                 "Failed when accessing the input vae model path memory."sv)
  MEM_SPAN_CHECK(OutputPathSpan, MemInst, char, OutputPathPtr, OutputPathLen,
                 "Failed when accessing the output path memory."sv)
  std::string ModelPath = std::string(
      ModelPathSpan.begin(), ModelPathSpan.begin() + ModelPathSpan.size());
  std::string VaeModelPath =
      std::string(VaeModelPathSpan.begin(),
                  VaeModelPathSpan.begin() + VaeModelPathSpan.size());
  std::string OutputPath = std::string(
      OutputPathSpan.begin(), OutputPathSpan.begin() + OutputPathSpan.size());

  spdlog::info("[WasmEdge-StableDiffusion] Convert model: {} to {}."sv,
               ModelPath.data(), OutputPath.data());
  std::ifstream Fin(ModelPath.data(), std::ios::in | std::ios::binary);
  if (!Fin) {
    Fin.close();
    spdlog::error("[WasmEdge-StableDiffusion] Model not found."sv);
    return static_cast<uint32_t>(ErrNo::InvalidArgument);
  }
  Fin.close();
  // Convert model.
  bool Ret = ::convert(ModelPath.data(), VaeModelPath.data(), OutputPath.data(),
                       static_cast<sd_type_t>(WType));
  if (!Ret) {
    spdlog::error("[WasmEdge-StableDiffusion] Failed to convert model."sv);
    return static_cast<uint32_t>(ErrNo::InvalidArgument);
  }

  return static_cast<uint32_t>(ErrNo::Success);
}

Expect<uint32_t> SDCreateContext::body(
    const Runtime::CallingFrame &Frame, uint32_t ModelPathPtr,