Function test_writeimage

test_conformance/basic/test_writeimage.cpp:120–196

template <typename T>
static int
test_writeimage(cl_device_id device, cl_context context, cl_command_queue queue,
                const cl_image_format *img_format, cl_mem_flags img_flags)
{
    clMemWrapper streams[2];
    clProgramWrapper program;
    clKernelWrapper kernel;

    std::string kernel_name("test_");

    size_t img_width = 512;
    size_t img_height = 512;

    int err;

    const size_t origin[3] = { 0, 0, 0 };
    const size_t region[3] = { img_width, img_height, 1 };

    const size_t num_elements = img_width * img_height * 4;
    const size_t length = num_elements * sizeof(T);

    PASSIVE_REQUIRE_IMAGE_SUPPORT(device)

    std::vector<T> input(num_elements);
    std::vector<T> output(num_elements);

    generate_random_inputs(input);

    streams[0] = create_image_2d(context, img_flags, img_format, img_width,
                                 img_height, 0, nullptr, &err);
    test_error(err, "create_image failed.");

    streams[1] =
        clCreateBuffer(context, CL_MEM_READ_WRITE, length, nullptr, &err);
    test_error(err, "clCreateBuffer failed.");

    err = clEnqueueWriteBuffer(queue, streams[1], CL_TRUE, 0, length,
                               input.data(), 0, nullptr, nullptr);
    test_error(err, "clEnqueueWriteImage failed.");

    kernel_name += GetChannelOrderName(img_format->image_channel_order);
    kernel_name += GetChannelTypeName(img_format->image_channel_data_type);

    err = create_single_kernel_helper(context, &program, &kernel, 1,
                                      &kernel_source, kernel_name.c_str());
    test_error(err, "create_single_kernel_helper failed.");

    err |= clSetKernelArg(kernel, 0, sizeof(streams[1]), &streams[1]);
    err |= clSetKernelArg(kernel, 1, sizeof(streams[0]), &streams[0]);
    test_error(err, "clSetKernelArgs failed\n");

    size_t threads[] = { img_width, img_height };
    err = clEnqueueNDRangeKernel(queue, kernel, 2, nullptr, threads, nullptr, 0,
                                 nullptr, nullptr);
    test_error(err, "clEnqueueNDRangeKernel failed\n");

    err = clEnqueueReadImage(queue, streams[0], CL_TRUE, origin, region, 0, 0,
                             output.data(), 0, nullptr, nullptr);