1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/source/helpers/validators.h"
#include "opencl/source/cl_device/cl_device.h"
#include "opencl/source/command_queue/command_queue.h"
#include "opencl/source/context/context.h"
#include "opencl/source/event/event.h"
#include "opencl/source/helpers/base_object.h"
#include "opencl/source/kernel/kernel.h"
#include "opencl/source/mem_obj/mem_obj.h"
#include "opencl/source/platform/platform.h"
#include "opencl/source/program/program.h"
#include "opencl/source/sampler/sampler.h"
namespace NEO {
cl_int validateObject(void *ptr) {
return ptr != nullptr
? CL_SUCCESS
: CL_INVALID_VALUE;
}
cl_int validateObject(cl_context object) {
return castToObject<Context>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_CONTEXT;
}
cl_int validateObject(cl_device_id object) {
return castToObject<ClDevice>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_DEVICE;
}
cl_int validateObject(cl_platform_id object) {
return castToObject<Platform>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_PLATFORM;
}
cl_int validateObject(cl_command_queue object) {
return castToObject<CommandQueue>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_COMMAND_QUEUE;
}
cl_int validateObject(cl_event object) {
return castToObject<Event>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_EVENT;
}
cl_int validateObject(cl_mem object) {
return castToObject<MemObj>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_MEM_OBJECT;
}
cl_int validateObject(cl_sampler object) {
return castToObject<Sampler>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_SAMPLER;
}
cl_int validateObject(cl_program object) {
return castToObject<Program>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_PROGRAM;
}
cl_int validateObject(cl_kernel object) {
return castToObject<Kernel>(object) != nullptr
? CL_SUCCESS
: CL_INVALID_KERNEL;
}
cl_int validateObject(const EventWaitList &eventWaitList) {
if ((!eventWaitList.first) != (!eventWaitList.second))
return CL_INVALID_EVENT_WAIT_LIST;
for (cl_uint i = 0; i < eventWaitList.first; i++) {
if (validateObject(eventWaitList.second[i]) != CL_SUCCESS)
return CL_INVALID_EVENT_WAIT_LIST;
}
return CL_SUCCESS;
}
cl_int validateObject(const DeviceList &deviceList) {
if ((!deviceList.first) != (!deviceList.second))
return CL_INVALID_VALUE;
for (cl_uint i = 0; i < deviceList.first; i++) {
if (validateObject(deviceList.second[i]) != CL_SUCCESS)
return CL_INVALID_DEVICE;
}
return CL_SUCCESS;
}
cl_int validateObject(const MemObjList &memObjList) {
if ((!memObjList.first) != (!memObjList.second))
return CL_INVALID_VALUE;
for (cl_uint i = 0; i < memObjList.first; i++) {
if (validateObject(memObjList.second[i]) != CL_SUCCESS)
return CL_INVALID_MEM_OBJECT;
}
return CL_SUCCESS;
}
cl_int validateObject(const NonZeroBufferSize &nzbs) {
return nzbs ? CL_SUCCESS : CL_INVALID_BUFFER_SIZE;
}
cl_int validateObject(const PatternSize &ps) {
switch ((cl_int)ps) {
case 128:
case 64:
case 32:
case 16:
case 8:
case 4:
case 2:
case 1:
return CL_SUCCESS;
default:
break;
}
return CL_INVALID_VALUE;
}
cl_int validateYuvOperation(const size_t *origin, const size_t *region) {
if (!origin || !region)
return CL_INVALID_VALUE;
return ((origin[0] % 2 == 0) && (region[0] % 2 == 0)) ? CL_SUCCESS : CL_INVALID_VALUE;
}
bool IsPackedYuvImage(const cl_image_format *imageFormat) {
auto channelOrder = imageFormat->image_channel_order;
return (channelOrder == CL_YUYV_INTEL) ||
(channelOrder == CL_UYVY_INTEL) ||
(channelOrder == CL_YVYU_INTEL) ||
(channelOrder == CL_VYUY_INTEL);
}
bool IsNV12Image(const cl_image_format *imageFormat) {
return imageFormat->image_channel_order == CL_NV12_INTEL;
}
} // namespace NEO
|
