rocm-systems/rocclr/runtime/device/rocm/rocglinterop.hpp

//
// Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved.
//
#pragma once

#ifndef WITHOUT_HSA_BACKEND

#ifdef _WIN32
// GLX header cannot be included in Windows due to X11 header dependency
#define MESA_GLINTEROP_NO_GLX
#include "device/rocm/mesa_glinterop.h"
// Give GLX parameters void* size
typedef void Display;
typedef void* GLXContext;
#undef MESA_GLINTEROP_NO_GLX
#else
#include "device/rocm/mesa_glinterop.h"
#endif

#include "device/rocm/rocregisters.hpp"
#include "hsa_ext_amd.h"

#include <atomic>

namespace roc {

// Specific typed container for version 1
typedef struct metadata_amd_ci_vi_s {
  uint32_t version;   // Must be 1
  uint32_t vendorID;  // AMD | CZ
  SQ_IMG_RSRC_WORD0 word0;
  SQ_IMG_RSRC_WORD1 word1;
  SQ_IMG_RSRC_WORD2 word2;
  SQ_IMG_RSRC_WORD3 word3;
  SQ_IMG_RSRC_WORD4 word4;
  SQ_IMG_RSRC_WORD5 word5;
  SQ_IMG_RSRC_WORD6 word6;
  SQ_IMG_RSRC_WORD7 word7;
  uint32_t mip_offsets[0];  // Mip level offset bits [39:8] for each level (if any)
} metadata_amd_ci_vi_t;

class image_metadata {
 private:
  metadata_amd_ci_vi_t* data;

  image_metadata(const image_metadata&) = delete;
  image_metadata& operator=(const image_metadata&) = delete;

 public:
  image_metadata() : data(nullptr) {}
  ~image_metadata() { data = nullptr; }

  bool create(hsa_amd_image_descriptor_t* image_desc) {
    if ((image_desc->version != 1) || ((image_desc->deviceID >> 16) != 0x1002)) return false;
    data = reinterpret_cast<metadata_amd_ci_vi_t*>(image_desc);
    return true;
  }

  bool setMipLevel(uint32_t level) {
    if (level > data->word3.bits.last_level) return false;
    data->word3.bits.base_level = level;
    data->word3.bits.last_level = level;
    return true;
  }

  bool setLayer(uint32_t layer) {
    data->word3.bits.type = SQ_RSRC_IMG_2D_ARRAY;
    data->word5.bits.last_array = layer;
    data->word5.bits.base_array = layer;
    return true;
  }

  bool setFace(GLenum face) {
    int index = face - GL_TEXTURE_CUBE_MAP_POSITIVE_X;
    if (index < 0 || index > 5) return false;
    if (data->word3.bits.type != SQ_RSRC_IMG_CUBE) return false;
    return setLayer(index);
  }
};

class MesaInterop {
 public:
  enum MESA_INTEROP_KIND { MESA_INTEROP_NONE = 0, MESA_INTEROP_GLX = 1, MESA_INTEROP_EGL = 2 };

  union DisplayHandle {
    Display* glxDisplay;
    EGLDisplay eglDisplay;
  };

  union ContextHandle {
    GLXContext glxContext;
    EGLContext eglContext;
  };

  // True if the configuration supports the indicated interop ability.
  static bool Supported();

  MesaInterop() { kind = MESA_INTEROP_NONE; }
  MesaInterop(const MesaInterop& rhs) { *this = rhs; }
  ~MesaInterop() { Unbind(); }

  const MesaInterop& operator=(const MesaInterop& rhs) {
    display = rhs.display;
    context = rhs.context;
    kind = rhs.kind;
    if (kind != MESA_INTEROP_NONE) refCount++;
    return *this;
  }

  /*
  Loads Mesa interop APIs and sets this interface object to use the indicated
  subsystem (GLX/EGL).  Returns true if the required subsystem is found.
  */
  bool Bind(MESA_INTEROP_KIND Kind, const DisplayHandle& Display, const ContextHandle& Context);

  /*
  Releases use of Mesa interop APIs.
  Used to check for bad load/unload sequences.
  */
  void Unbind() {
    if (kind == MESA_INTEROP_NONE) return;
    assert(refCount > 0 && "Invalid refCount in MesaInterop.");
    refCount--;
    kind = MESA_INTEROP_NONE;
  }

  bool GetInfo(mesa_glinterop_device_info& info) const;

  bool Export(mesa_glinterop_export_in& in, mesa_glinterop_export_out& out) const;

 private:
  static std::atomic<uint32_t> refCount;

  DisplayHandle display;
  ContextHandle context;
  MESA_INTEROP_KIND kind;
};
}

#endif /*WITHOUT_HSA_BACKEND*/