Function ihipMipmapArrayCreate

hipamd/src/hip_memory.cpp:4159–4226

}

hipError_t ihipMipmapArrayCreate(hipMipmappedArray_t* mipmapped_array_pptr,
                                 HIP_ARRAY3D_DESCRIPTOR* mipmapped_array_desc_ptr,
                                 unsigned int num_mipmap_levels, size_t offset = 0,
                                 amd::Memory* buffer = nullptr) {
  bool mipMapSupport = true;
  amd::Context& context = *hip::getCurrentDevice()->asContext();
  const std::vector<amd::Device*>& devices = context.devices();
  for (auto& dev : devices) {
    if (!dev->settings().checkExtension(ClKhrMipMapImage)) {
      mipMapSupport = false;
    }
  }
  if (mipMapSupport == false) {
    LogPrintfError("Mipmap not supported on one of the devices, Mip Level: %d", num_mipmap_levels);
    return hipErrorNotSupported;
  }
  if (!mipmapped_array_pptr || !mipmapped_array_desc_ptr) {
    return hipErrorInvalidValue;
  }
  unsigned int flags = hipArrayDefault | hipArrayLayered | hipArraySurfaceLoadStore |
                       hipArrayTextureGather;  // hipArrayCubemap isn't supported
  if (mipmapped_array_desc_ptr->Flags & (~flags)) {
    return hipErrorInvalidValue;
  }
  if (mipmapped_array_desc_ptr->Flags & hipArrayTextureGather) {
    // hipArrayTextureGather only works for 2D
    if (mipmapped_array_desc_ptr->Width == 0 || mipmapped_array_desc_ptr->Height == 0 ||
        mipmapped_array_desc_ptr->Depth > 0)
      return hipErrorInvalidValue;
  }

  const cl_channel_order channel_order =
      hip::getCLChannelOrder(mipmapped_array_desc_ptr->NumChannels, 0);
  const cl_channel_type channel_type =
      hip::getCLChannelType(mipmapped_array_desc_ptr->Format, hipReadModeElementType);
  const cl_mem_object_type image_type =
      hip::getCLMemObjectType(mipmapped_array_desc_ptr->Width, mipmapped_array_desc_ptr->Height,
                              mipmapped_array_desc_ptr->Depth, mipmapped_array_desc_ptr->Flags);
  hipError_t status = hipSuccess;
  // Create a new amd::Image with mipmap
  amd::Image* image =
      ihipImageCreate(channel_order, channel_type, image_type, mipmapped_array_desc_ptr->Width,
                      mipmapped_array_desc_ptr->Height, mipmapped_array_desc_ptr->Depth,
                      mipmapped_array_desc_ptr->Depth, 0 /* row pitch */, 0 /* slice pitch */,
                      num_mipmap_levels, offset, buffer, status);

  if (image == nullptr) {
    return status;
  }

  cl_mem cl_mem_obj = as_cl<amd::Memory>(image);
  *mipmapped_array_pptr = new hipMipmappedArray();
  (*mipmapped_array_pptr)->data = reinterpret_cast<void*>(cl_mem_obj);

  (*mipmapped_array_pptr)->desc = hip::getChannelFormatDesc(mipmapped_array_desc_ptr->NumChannels,
                                                            mipmapped_array_desc_ptr->Format);
  (*mipmapped_array_pptr)->type = image_type;
  (*mipmapped_array_pptr)->width = mipmapped_array_desc_ptr->Width;