opencl/colors.cl.h


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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494

static const char* colors_cl_source =
"/* This file is part of GEGL                                                  \n"
" *                                                                            \n"
" * GEGL is free software; you can redistribute it and/or                      \n"
" * modify it under the terms of the GNU Lesser General Public                 \n"
" * License as published by the Free Software Foundation; either               \n"
" * version 3 of the License, or (at your option) any later version.           \n"
" *                                                                            \n"
" * GEGL is distributed in the hope that it will be useful,                    \n"
" * but WITHOUT ANY WARRANTY; without even the implied warranty of             \n"
" * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU          \n"
" * Lesser General Public License for more details.                            \n"
" *                                                                            \n"
" * You should have received a copy of the GNU Lesser General Public           \n"
" * License along with GEGL; if not, see <http://www.gnu.org/licenses/>.       \n"
" *                                                                            \n"
" * Copyright 2012 Victor Oliveira (victormatheus@gmail.com)                   \n"
" */                                                                           \n"
"                                                                              \n"
"/* This is almost a copy-paste from babl/base color conversion functions      \n"
"                                                                              \n"
"   XXX: This code is very hard to maintain and keep in sync with BABL, we should\n"
"        think in something better                                             \n"
"*/                                                                            \n"
"                                                                              \n"
"/* Alpha threshold used in the reference implementation for                   \n"
" * un-pre-multiplication of color data:                                       \n"
" *                                                                            \n"
" * 0.01 / (2^16 - 1)                                                          \n"
" */                                                                           \n"
"#define BABL_ALPHA_THRESHOLD 0.0f                                             \n"
"                                                                              \n"
"/* babl reference file: babl/base/util.h */                                   \n"
"float linear_to_gamma_2_2 (float value)                                       \n"
"{                                                                             \n"
"  if (value > 0.003130804954f)                                                \n"
"    return 1.055f * native_powr (value, (1.0f/2.4f)) - 0.055f;                \n"
"  return 12.92f * value;                                                      \n"
"}                                                                             \n"
"                                                                              \n"
"float gamma_2_2_to_linear (float value)                                       \n"
"{                                                                             \n"
"  if (value > 0.04045f)                                                       \n"
"    return native_powr ((value + 0.055f) / 1.055f, 2.4f);                     \n"
"  return value / 12.92f;                                                      \n"
"}                                                                             \n"
"                                                                              \n"
"/* -- RGBA float/u8 -- */                                                     \n"
"                                                                              \n"
"/* RGBA u8 -> RGBA float */                                                   \n"
"__kernel void rgbau8_to_rgbaf (__global const uchar4 * in,                    \n"
"                               __global       float4 * out)                   \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = convert_float4(in[gid]) / 255.0f;                            \n"
"  float4 out_v = in_v;                                                        \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* RGBA float -> RGBA u8 */                                                   \n"
"__kernel void rgbaf_to_rgbau8 (__global const float4 * in,                    \n"
"                               __global       uchar4 * out)                   \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v = in_v;                                                        \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* -- RaGaBaA float -- */                                                     \n"
"                                                                              \n"
"/* RGBA float -> RaGaBaA float */                                             \n"
"__kernel void rgbaf_to_ragabaf (__global const float4 * in,                   \n"
"                                __global       float4 * out)                  \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v = in[gid];                                                      \n"
"  float4 out_v;                                                               \n"
"  out_v   = in_v * in_v.w;                                                    \n"
"  out_v.w = in_v.w;                                                           \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"                                                                              \n"
"/* RaGaBaA float -> RGBA float */                                             \n"
"__kernel void ragabaf_to_rgbaf (__global const float4 * in,                   \n"
"                                __global       float4 * out)                  \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"  out_v = (in_v.w > BABL_ALPHA_THRESHOLD)? in_v / in_v.w : (float4)(0.0f);    \n"
"  out_v.w = in_v.w;                                                           \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* RGBA u8 -> RaGaBaA float */                                                \n"
"__kernel void rgbau8_to_ragabaf (__global const uchar4 * in,                  \n"
"                                 __global       float4 * out)                 \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = convert_float4(in[gid]) / 255.0f;                            \n"
"  float4 out_v;                                                               \n"
"  out_v   = in_v * in_v.w;                                                    \n"
"  out_v.w = in_v.w;                                                           \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"                                                                              \n"
"/* RaGaBaA float -> RGBA u8 */                                                \n"
"__kernel void ragabaf_to_rgbau8 (__global const float4 * in,                  \n"
"                                 __global       uchar4 * out)                 \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"  out_v = (in_v.w > BABL_ALPHA_THRESHOLD)? in_v / in_v.w : (float4)(0.0f);    \n"
"  out_v.w = in_v.w;                                                           \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* RaGaBaA float -> RGBA_GAMMA_U8 */                                          \n"
"__kernel void ragabaf_to_rgba_gamma_u8 (__global const float4 * in,           \n"
"                                        __global       uchar4 * out)          \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 tmp_v;                                                               \n"
"  tmp_v = (in_v.w > BABL_ALPHA_THRESHOLD)? in_v / in_v.w : (float4)(0.0f);    \n"
"  tmp_v.w = in_v.w;                                                           \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(linear_to_gamma_2_2(tmp_v.x),                              \n"
"                   linear_to_gamma_2_2(tmp_v.y),                              \n"
"                   linear_to_gamma_2_2(tmp_v.z),                              \n"
"                   tmp_v.w);                                                  \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* RaGaBaA float -> RGB_GAMMA_U8 */                                           \n"
"__kernel void ragabaf_to_rgb_gamma_u8 (__global const float4 * in,            \n"
"                                       __global       uchar  * out)           \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 tmp_v;                                                               \n"
"  tmp_v = (in_v.w > BABL_ALPHA_THRESHOLD)? in_v / in_v.w : (float4)(0.0f);    \n"
"  tmp_v.w = in_v.w;                                                           \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(linear_to_gamma_2_2(tmp_v.x),                              \n"
"                   linear_to_gamma_2_2(tmp_v.y),                              \n"
"                   linear_to_gamma_2_2(tmp_v.z),                              \n"
"                   tmp_v.w);                                                  \n"
"#if (__OPENCL_VERSION__ != CL_VERSION_1_0)                                    \n"
"  vstore3 (convert_uchar3_sat_rte(255.0f * out_v.xyz), gid, out);             \n"
"#else                                                                         \n"
"  uchar4 sat = convert_uchar4_sat_rte (255.0f * out_v);                       \n"
"  out[3 * gid]     = sat.x;                                                   \n"
"  out[3 * gid + 1] = sat.y;                                                   \n"
"  out[3 * gid + 2] = sat.z;                                                   \n"
"#endif                                                                        \n"
"}                                                                             \n"
"                                                                              \n"
"/* -- R'G'B'A float -- */                                                     \n"
"                                                                              \n"
"/* rgba float -> r'g'b'a float */                                             \n"
"__kernel void rgbaf_to_rgba_gamma_f (__global const float4 * in,              \n"
"                                     __global       float4 * out)             \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(linear_to_gamma_2_2(in_v.x),                               \n"
"                   linear_to_gamma_2_2(in_v.y),                               \n"
"                   linear_to_gamma_2_2(in_v.z),                               \n"
"                   in_v.w);                                                   \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* r'g'b'a float -> rgba float */                                             \n"
"__kernel void rgba_gamma_f_to_rgbaf (__global const float4 * in,              \n"
"                                     __global       float4 * out)             \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(gamma_2_2_to_linear(in_v.x),                               \n"
"                   gamma_2_2_to_linear(in_v.y),                               \n"
"                   gamma_2_2_to_linear(in_v.z),                               \n"
"                   in_v.w);                                                   \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* rgba u8 -> r'g'b'a float */                                                \n"
"__kernel void rgbau8_to_rgba_gamma_f (__global const uchar4 * in,             \n"
"                                      __global       float4 * out)            \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = convert_float4(in[gid]) / 255.0f;                            \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(linear_to_gamma_2_2(in_v.x),                               \n"
"                   linear_to_gamma_2_2(in_v.y),                               \n"
"                   linear_to_gamma_2_2(in_v.z),                               \n"
"                   in_v.w);                                                   \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* r'g'b'a float -> rgba u8 */                                                \n"
"__kernel void rgba_gamma_f_to_rgbau8 (__global const float4 * in,             \n"
"                                      __global       uchar4 * out)            \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(gamma_2_2_to_linear(in_v.x),                               \n"
"                   gamma_2_2_to_linear(in_v.y),                               \n"
"                   gamma_2_2_to_linear(in_v.z),                               \n"
"                   in_v.w);                                                   \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* -- Y'CbCrA float -- */                                                     \n"
"                                                                              \n"
"/* RGBA float -> Y'CbCrA float */                                             \n"
"__kernel void rgbaf_to_ycbcraf (__global const float4 * in,                   \n"
"                                __global       float4 * out)                  \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"                                                                              \n"
"#if (__OPENCL_VERSION__ != CL_VERSION_1_0)                                    \n"
"  float3 rgb = (float3)(linear_to_gamma_2_2(in_v.x),                          \n"
"                        linear_to_gamma_2_2(in_v.y),                          \n"
"                        linear_to_gamma_2_2(in_v.z));                         \n"
"#else                                                                         \n"
"  float4 rgb = (float4)(linear_to_gamma_2_2(in_v.x),                          \n"
"                        linear_to_gamma_2_2(in_v.y),                          \n"
"                        linear_to_gamma_2_2(in_v.z), 1.0f);                   \n"
"#endif                                                                        \n"
"                                                                              \n"
"  out_v = (float4)( 0.299f    * rgb.x + 0.587f    * rgb.y + 0.114f    * rgb.z,\n"
"                   -0.168736f * rgb.x - 0.331264f * rgb.y + 0.5f      * rgb.z,\n"
"                    0.5f      * rgb.x - 0.418688f * rgb.y - 0.081312f * rgb.z,\n"
"                   in_v.w);                                                   \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* Y'CbCrA float -> RGBA float */                                             \n"
"__kernel void ycbcraf_to_rgbaf (__global const float4 * in,                   \n"
"                                __global       float4 * out)                  \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"                                                                              \n"
"  float4 rgb = (float4)(1.0f * in_v.x + 0.0f      * in_v.y + 1.40200f    * in_v.z,\n"
"                        1.0f * in_v.x - 0.344136f * in_v.y - 0.71414136f * in_v.z,\n"
"                        1.0f * in_v.x + 1.772f    * in_v.y + 0.0f        * in_v.z,\n"
"                        0.0f);                                                \n"
"                                                                              \n"
"  out_v = (float4)(gamma_2_2_to_linear(rgb.x),                                \n"
"                   gamma_2_2_to_linear(rgb.y),                                \n"
"                   gamma_2_2_to_linear(rgb.z),                                \n"
"                   in_v.w);                                                   \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* RGBA u8 -> Y'CbCrA float */                                                \n"
"__kernel void rgbau8_to_ycbcraf (__global const uchar4 * in,                  \n"
"                                 __global       float4 * out)                 \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = convert_float4(in[gid]) / 255.0f;                            \n"
"  float4 out_v;                                                               \n"
"                                                                              \n"
"  float4 rgb = (float4)(linear_to_gamma_2_2(in_v.x),                          \n"
"                        linear_to_gamma_2_2(in_v.y),                          \n"
"                        linear_to_gamma_2_2(in_v.z),                          \n"
"                        0.0f);                                                \n"
"                                                                              \n"
"  out_v = (float4)( 0.299f    * rgb.x + 0.587f    * rgb.y + 0.114f    * rgb.z,\n"
"                   -0.168736f * rgb.x - 0.331264f * rgb.y + 0.5f      * rgb.z,\n"
"                    0.5f      * rgb.x - 0.418688f * rgb.y - 0.081312f * rgb.z,\n"
"                   in_v.w);                                                   \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* Y'CbCrA float -> RGBA u8 */                                                \n"
"__kernel void ycbcraf_to_rgbau8 (__global const float4 * in,                  \n"
"                                 __global       uchar4 * out)                 \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"                                                                              \n"
"  float4 rgb = (float4)(1.0f * in_v.x + 0.0f      * in_v.y + 1.40200f    * in_v.z,\n"
"                        1.0f * in_v.x - 0.344136f * in_v.y - 0.71414136f * in_v.z,\n"
"                        1.0f * in_v.x + 1.772f    * in_v.y + 0.0f        * in_v.z,\n"
"                        0.0f);                                                \n"
"                                                                              \n"
"  out_v = (float4)(gamma_2_2_to_linear(rgb.x),                                \n"
"                   gamma_2_2_to_linear(rgb.y),                                \n"
"                   gamma_2_2_to_linear(rgb.z),                                \n"
"                   in_v.w);                                                   \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* -- RGB u8 -- */                                                            \n"
"                                                                              \n"
"/* RGB u8 -> RGBA float */                                                    \n"
"__kernel void rgbu8_to_rgbaf (__global const uchar  * in,                     \n"
"                              __global       float4 * out)                    \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"#if (__OPENCL_VERSION__ != CL_VERSION_1_0)                                    \n"
"  uchar3 in_v;                                                                \n"
"  float4 out_v;                                                               \n"
"  in_v = vload3 (gid, in);                                                    \n"
"  out_v.xyz = convert_float3(in_v) / 255.0f;                                  \n"
"  out_v.w   = 1.0f;                                                           \n"
"#else                                                                         \n"
"  uchar4 in_v = (uchar4) (in[3 * gid], in[3 * gid + 1], in[3 * gid + 2], 255);\n"
"  float4 out_v = convert_float4 (in_v) / 255.0f;                              \n"
"#endif                                                                        \n"
"  out[gid]  = out_v;                                                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* RGBA float -> RGB u8 */                                                    \n"
"__kernel void rgbaf_to_rgbu8 (__global const float4 * in,                     \n"
"                              __global       uchar  * out)                    \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"#if (__OPENCL_VERSION__ != CL_VERSION_1_0)                                    \n"
"  uchar3 out_v = convert_uchar3_sat_rte(255.0f * in_v.xyz);                   \n"
"  vstore3 (out_v, gid, out);                                                  \n"
"#else                                                                         \n"
"  uchar4 out_v = convert_uchar4_sat_rte(255.0f * in_v);                       \n"
"  out[3 * gid]     = out_v.x;                                                 \n"
"  out[3 * gid + 1] = out_v.y;                                                 \n"
"  out[3 * gid + 2] = out_v.z;                                                 \n"
"#endif                                                                        \n"
"}                                                                             \n"
"                                                                              \n"
"/* -- Y u8 -- */                                                              \n"
"                                                                              \n"
"/* Y u8 -> Y float */                                                         \n"
"__kernel void yu8_to_yf (__global const uchar * in,                           \n"
"                         __global       float * out)                          \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float in_v  = convert_float (in[gid]) / 255.0f;                             \n"
"  float out_v;                                                                \n"
"  out_v = in_v;                                                               \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* -- YA float -- */                                                          \n"
"                                                                              \n"
"/* babl reference file: babl/base/rgb-constants.h */                          \n"
"#define RGB_LUMINANCE_RED    (0.222491f)                                      \n"
"#define RGB_LUMINANCE_GREEN  (0.716888f)                                      \n"
"#define RGB_LUMINANCE_BLUE   (0.060621f)                                      \n"
"                                                                              \n"
"/* RGBA float -> YA float */                                                  \n"
"__kernel void rgbaf_to_yaf (__global const float4 * in,                       \n"
"                            __global       float2 * out)                      \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float2 out_v;                                                               \n"
"                                                                              \n"
"  float luminance = in_v.x * RGB_LUMINANCE_RED +                              \n"
"                    in_v.y * RGB_LUMINANCE_GREEN +                            \n"
"                    in_v.z * RGB_LUMINANCE_BLUE;                              \n"
"                                                                              \n"
"  out_v.x = luminance;                                                        \n"
"  out_v.y = in_v.w;                                                           \n"
"                                                                              \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* YA float -> RGBA float */                                                  \n"
"__kernel void yaf_to_rgbaf (__global const float2 * in,                       \n"
"                            __global       float4 * out)                      \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float2 in_v  = in[gid];                                                     \n"
"  float4 out_v = (float4) (in_v.x, in_v.x, in_v.x, in_v.y);                   \n"
"                                                                              \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* RGBA u8 -> YA float */                                                     \n"
"__kernel void rgbau8_to_yaf (__global const uchar4 * in,                      \n"
"                             __global       float2 * out)                     \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = convert_float4(in[gid]) / 255.0f;                            \n"
"  float2 out_v;                                                               \n"
"                                                                              \n"
"  float luminance = in_v.x * RGB_LUMINANCE_RED +                              \n"
"                    in_v.y * RGB_LUMINANCE_GREEN +                            \n"
"                    in_v.z * RGB_LUMINANCE_BLUE;                              \n"
"                                                                              \n"
"  out_v.x = luminance;                                                        \n"
"  out_v.y = in_v.w;                                                           \n"
"                                                                              \n"
"  out[gid] = out_v;                                                           \n"
"}                                                                             \n"
"                                                                              \n"
"/* YA float -> RGBA u8 */                                                     \n"
"__kernel void yaf_to_rgbau8 (__global const float2 * in,                      \n"
"                             __global       uchar4 * out)                     \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float2 in_v  = in[gid];                                                     \n"
"  float4 out_v = (float4) (in_v.x, in_v.x, in_v.x, in_v.y);                   \n"
"                                                                              \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* YA float -> R'G'B'A u8 */                                                  \n"
"__kernel void yaf_to_rgba_gamma_u8 (__global const float2 * in,               \n"
"                                    __global       uchar4 * out)              \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float2 in_v  = in[gid];                                                     \n"
"  float4 tmp_v = (float4) (in_v.x, in_v.x, in_v.x, in_v.y);                   \n"
"                                                                              \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(linear_to_gamma_2_2(tmp_v.x),                              \n"
"                   linear_to_gamma_2_2(tmp_v.y),                              \n"
"                   linear_to_gamma_2_2(tmp_v.z),                              \n"
"                   tmp_v.w);                                                  \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* YA float -> R'G'B' u8 */                                                   \n"
"__kernel void yaf_to_rgb_gamma_u8 (__global const float2 * in,                \n"
"                                   __global       uchar  * out)               \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float2 in_v  = in[gid];                                                     \n"
"  uchar  tmp = convert_uchar_sat_rte (255.0f * linear_to_gamma_2_2 (in_v.x)); \n"
"                                                                              \n"
"#if (__OPENCL_VERSION__ != CL_VERSION_1_0)                                    \n"
"  vstore3 ((uchar3)tmp, gid, out);                                            \n"
"#else                                                                         \n"
"  out[3 * gid] = out[3 * gid + 1] = out[3 * gid + 2] = tmp;                   \n"
"#endif                                                                        \n"
"}                                                                             \n"
"                                                                              \n"
"/* R'G'B'A u8 */                                                              \n"
"                                                                              \n"
"/* rgba float -> r'g'b'a u8 */                                                \n"
"__kernel void rgbaf_to_rgba_gamma_u8 (__global const float4 * in,             \n"
"                                      __global       uchar4 * out)            \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 out_v;                                                               \n"
"  out_v = (float4)(linear_to_gamma_2_2(in_v.x),                               \n"
"                   linear_to_gamma_2_2(in_v.y),                               \n"
"                   linear_to_gamma_2_2(in_v.z),                               \n"
"                   in_v.w);                                                   \n"
"  out[gid] = convert_uchar4_sat_rte(255.0f * out_v);                          \n"
"}                                                                             \n"
"                                                                              \n"
"/* R'G'B' u8 */                                                               \n"
"                                                                              \n"
"/* rgba float -> r'g'b' u8 */                                                 \n"
"__kernel void rgbaf_to_rgb_gamma_u8 (__global const float4 * in,              \n"
"                                     __global       uchar  * out)             \n"
"{                                                                             \n"
"  int gid = get_global_id(0);                                                 \n"
"  float4 in_v  = in[gid];                                                     \n"
"  float4 tmp_v;                                                               \n"
"  tmp_v = (float4)(linear_to_gamma_2_2(in_v.x),                               \n"
"                   linear_to_gamma_2_2(in_v.y),                               \n"
"                   linear_to_gamma_2_2(in_v.z),                               \n"
"                   in_v.w);                                                   \n"
"#if (__OPENCL_VERSION__ != CL_VERSION_1_0)                                    \n"
"  uchar3 out_v;                                                               \n"
"  out_v = convert_uchar3_sat_rte(255.0f * tmp_v.xyz);                         \n"
"  vstore3 (out_v, gid, out);                                                  \n"
"#else                                                                         \n"
"  uchar4 out_v = convert_uchar4_sat_rte (255.0f * tmp_v);                     \n"
"  out[3 * gid]     = out_v.x;                                                 \n"
"  out[3 * gid + 1] = out_v.y;                                                 \n"
"  out[3 * gid + 2] = out_v.z;                                                 \n"
"#endif                                                                        \n"
"}                                                                             \n"
;