tu: Implement fallback linear staging blit for CopyImage

[mesa.git] / src / gallium / state_trackers / clover / api / context.cpp

diff --git a/src/gallium/state_trackers/clover/api/context.cpp b/src/gallium/state_trackers/clover/api/context.cpp
index 371744120eed586b1cf485773034b6cdc00925e9..c0cd2d32b95a96c158c432940063df9caab4828d 100644 (file)
--- a/src/gallium/state_trackers/clover/api/context.cpp
+++ b/src/gallium/state_trackers/clover/api/context.cpp
@@ -22,106 +22,123 @@
 
 #include "api/util.hpp"
 #include "core/context.hpp"
+#include "core/platform.hpp"
 
 using namespace clover;
 
-PUBLIC cl_context
-clCreateContext(const cl_context_properties *props, cl_uint num_devs,
-                const cl_device_id *devs,
+CLOVER_API cl_context
+clCreateContext(const cl_context_properties *d_props, cl_uint num_devs,
+                const cl_device_id *d_devs,
                 void (CL_CALLBACK *pfn_notify)(const char *, const void *,
                                                size_t, void *),
-                void *user_data, cl_int *errcode_ret) try {
-   auto mprops = property_map(props);
+                void *user_data, cl_int *r_errcode) try {
+   auto props = obj<property_list_tag>(d_props);
+   auto devs = objs(d_devs, num_devs);
 
-   if (!devs || !num_devs ||
-       (!pfn_notify && user_data))
+   if (!pfn_notify && user_data)
       throw error(CL_INVALID_VALUE);
 
-   if (any_of(is_zero<cl_device_id>, devs, devs + num_devs))
-      throw error(CL_INVALID_DEVICE);
-
-   for (auto p : mprops) {
-      if (p.first != CL_CONTEXT_PLATFORM)
+   for (auto &prop : props) {
+      if (prop.first == CL_CONTEXT_PLATFORM)
+         obj(prop.second.as<cl_platform_id>());
+      else
          throw error(CL_INVALID_PROPERTY);
    }
 
-   ret_error(errcode_ret, CL_SUCCESS);
-   return new context(
-      property_vector(mprops),
-      std::vector<cl_device_id>(devs, devs + num_devs));
+   const auto notify = (!pfn_notify ? context::notify_action() :
+                        [=](const char *s) {
+                           pfn_notify(s, NULL, 0, user_data);
+                        });
+
+   ret_error(r_errcode, CL_SUCCESS);
+   return desc(new context(props, devs, notify));
 
-} catch(error &e) {
-   ret_error(errcode_ret, e);
+} catch (error &e) {
+   ret_error(r_errcode, e);
    return NULL;
 }
 
-PUBLIC cl_context
-clCreateContextFromType(const cl_context_properties *props,
+CLOVER_API cl_context
+clCreateContextFromType(const cl_context_properties *d_props,
                         cl_device_type type,
                         void (CL_CALLBACK *pfn_notify)(
                            const char *, const void *, size_t, void *),
-                        void *user_data, cl_int *errcode_ret) try {
-   cl_platform_id platform;
+                        void *user_data, cl_int *r_errcode) try {
+   cl_platform_id d_platform;
    cl_uint num_platforms;
-   cl_device_id dev;
    cl_int ret;
+   std::vector<cl_device_id> devs;
+   cl_uint num_devices;
 
-   ret = clGetPlatformIDs(1, &platform, &num_platforms);
+   ret = clGetPlatformIDs(1, &d_platform, &num_platforms);
    if (ret || !num_platforms)
       throw error(CL_INVALID_PLATFORM);
 
-   ret = clGetDeviceIDs(platform, type, 1, &dev, 0);
+   ret = clGetDeviceIDs(d_platform, type, 0, NULL, &num_devices);
+   if (ret)
+      throw error(CL_DEVICE_NOT_FOUND);
+   devs.resize(num_devices);
+   ret = clGetDeviceIDs(d_platform, type, num_devices, devs.data(), 0);
    if (ret)
       throw error(CL_DEVICE_NOT_FOUND);
 
-   return clCreateContext(props, 1, &dev, pfn_notify, user_data, errcode_ret);
+   return clCreateContext(d_props, num_devices, devs.data(), pfn_notify,
+                          user_data, r_errcode);
 
-} catch(error &e) {
-   ret_error(errcode_ret, e);
+} catch (error &e) {
+   ret_error(r_errcode, e);
    return NULL;
 }
 
-PUBLIC cl_int
-clRetainContext(cl_context ctx) {
-   if (!ctx)
-      return CL_INVALID_CONTEXT;
-
-   ctx->retain();
+CLOVER_API cl_int
+clRetainContext(cl_context d_ctx) try {
+   obj(d_ctx).retain();
    return CL_SUCCESS;
-}
 
-PUBLIC cl_int
-clReleaseContext(cl_context ctx) {
-   if (!ctx)
-      return CL_INVALID_CONTEXT;
+} catch (error &e) {
+   return e.get();
+}
 
-   if (ctx->release())
-      delete ctx;
+CLOVER_API cl_int
+clReleaseContext(cl_context d_ctx) try {
+   if (obj(d_ctx).release())
+      delete pobj(d_ctx);
 
    return CL_SUCCESS;
+
+} catch (error &e) {
+   return e.get();
 }
 
-PUBLIC cl_int
-clGetContextInfo(cl_context ctx, cl_context_info param,
-                 size_t size, void *buf, size_t *size_ret) {
-   if (!ctx)
-      return CL_INVALID_CONTEXT;
+CLOVER_API cl_int
+clGetContextInfo(cl_context d_ctx, cl_context_info param,
+                 size_t size, void *r_buf, size_t *r_size) try {
+   property_buffer buf { r_buf, size, r_size };
+   auto &ctx = obj(d_ctx);
 
    switch (param) {
    case CL_CONTEXT_REFERENCE_COUNT:
-      return scalar_property<cl_uint>(buf, size, size_ret, ctx->ref_count());
+      buf.as_scalar<cl_uint>() = ctx.ref_count();
+      break;
 
    case CL_CONTEXT_NUM_DEVICES:
-      return scalar_property<cl_uint>(buf, size, size_ret, ctx->devs.size());
+      buf.as_scalar<cl_uint>() = ctx.devices().size();
+      break;
 
    case CL_CONTEXT_DEVICES:
-      return vector_property<cl_device_id>(buf, size, size_ret, ctx->devs);
+      buf.as_vector<cl_device_id>() = descs(ctx.devices());
+      break;
 
    case CL_CONTEXT_PROPERTIES:
-      return vector_property<cl_context_properties>(buf, size, size_ret,
-                                                    ctx->props());
+      buf.as_vector<cl_context_properties>() = desc(ctx.properties());
+      break;
 
    default:
-      return CL_INVALID_VALUE;
+      throw error(CL_INVALID_VALUE);
    }
+
+   return CL_SUCCESS;
+
+} catch (error &e) {
+   return e.get();
 }