GFXprim
2D bitmap graphics library with emphasis on speed and correctness
Loading...
Searching...
No Matches
gp_convert.gen.h
Go to the documentation of this file.
1// SPDX-License-Identifier: GPL-2.1-or-later
2/*
3 * gp_convert.gen.h
4 *
5 * GENERATED on 2025 11 30 21:24:31 from gp_convert.gen.h.t
6 *
7 * DO NOT MODIFY THIS FILE DIRECTLY!
8 */
9#ifndef GP_CONVERT_GEN_H
10#define GP_CONVERT_GEN_H
11
12/*
13 * Copyright (C) 2011-2024 Cyril Hrubis <metan@ucw.cz>
14 * Copyright (C) 2011 Tomas Gavenciak <gavento@ucw.cz>
15 */
16
21
22#include <core/gp_get_set_bits.h>
23#include <core/gp_pixmap.h>
24#include <core/gp_pixel.h>
25
26/*
27 * Converts RGB888 -> RGB101010
28 *
29 * macro reads p1 (RGB888 at bit-offset o1)
30 * and writes to p2 (RGB101010 at bit-offset o2)
31 * the relevant part of p2 is assumed to be cleared (zero)
32 */
33#define GP_PIXEL_RGB888_TO_RGB101010_OFFSET(p1, o1, p2, o2) do { \
34 /* R:=R */ GP_SET_BITS(20+o2, 10, p2,\
35 GP_SCALE_VAL_8_10(GP_GET_BITS(16+o1, 8, p1))); \
36 /* G:=G */ GP_SET_BITS(10+o2, 10, p2,\
37 GP_SCALE_VAL_8_10(GP_GET_BITS(8+o1, 8, p1))); \
38 /* B:=B */ GP_SET_BITS(0+o2, 10, p2,\
39 GP_SCALE_VAL_8_10(GP_GET_BITS(0+o1, 8, p1))); \
40} while (0)
41
42/* a version without offsets */
43#define GP_PIXEL_RGB888_TO_RGB101010(p1, p2) \
44 GP_PIXEL_RGB888_TO_RGB101010_OFFSET(p1, 0, p2, 0)
45
46/*
47 * Converts RGB101010 -> RGB888
48 *
49 * macro reads p1 (RGB101010 at bit-offset o1)
50 * and writes to p2 (RGB888 at bit-offset o2)
51 * the relevant part of p2 is assumed to be cleared (zero)
52 */
53#define GP_PIXEL_RGB101010_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
54 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
55 GP_SCALE_VAL_10_8(GP_GET_BITS(20+o1, 10, p1))); \
56 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
57 GP_SCALE_VAL_10_8(GP_GET_BITS(10+o1, 10, p1))); \
58 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
59 GP_SCALE_VAL_10_8(GP_GET_BITS(0+o1, 10, p1))); \
60} while (0)
61
62/* a version without offsets */
63#define GP_PIXEL_RGB101010_TO_RGB888(p1, p2) \
64 GP_PIXEL_RGB101010_TO_RGB888_OFFSET(p1, 0, p2, 0)
65
66/*
67 * Converts RGB888 -> xRGB8888
68 *
69 * macro reads p1 (RGB888 at bit-offset o1)
70 * and writes to p2 (xRGB8888 at bit-offset o2)
71 * the relevant part of p2 is assumed to be cleared (zero)
72 */
73#define GP_PIXEL_RGB888_TO_xRGB8888_OFFSET(p1, o1, p2, o2) do { \
74 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
75 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
76 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
77 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
78 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
79 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
80} while (0)
81
82/* a version without offsets */
83#define GP_PIXEL_RGB888_TO_xRGB8888(p1, p2) \
84 GP_PIXEL_RGB888_TO_xRGB8888_OFFSET(p1, 0, p2, 0)
85
86/*
87 * Converts xRGB8888 -> RGB888
88 *
89 * macro reads p1 (xRGB8888 at bit-offset o1)
90 * and writes to p2 (RGB888 at bit-offset o2)
91 * the relevant part of p2 is assumed to be cleared (zero)
92 */
93#define GP_PIXEL_xRGB8888_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
94 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
95 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
96 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
97 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
98 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
99 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
100} while (0)
101
102/* a version without offsets */
103#define GP_PIXEL_xRGB8888_TO_RGB888(p1, p2) \
104 GP_PIXEL_xRGB8888_TO_RGB888_OFFSET(p1, 0, p2, 0)
105
106/*
107 * Converts RGB888 -> RGBA8888
108 *
109 * macro reads p1 (RGB888 at bit-offset o1)
110 * and writes to p2 (RGBA8888 at bit-offset o2)
111 * the relevant part of p2 is assumed to be cleared (zero)
112 */
113#define GP_PIXEL_RGB888_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
114 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
115 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
116 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
117 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
118 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
119 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
120 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
121} while (0)
122
123/* a version without offsets */
124#define GP_PIXEL_RGB888_TO_RGBA8888(p1, p2) \
125 GP_PIXEL_RGB888_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
126
127/*
128 * Converts RGB888 -> RGB888
129 *
130 * macro reads p1 (RGB888 at bit-offset o1)
131 * and writes to p2 (RGB888 at bit-offset o2)
132 * the relevant part of p2 is assumed to be cleared (zero)
133 */
134#define GP_PIXEL_RGB888_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
135 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
136 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
137 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
138 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
139 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
140 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
141} while (0)
142
143/* a version without offsets */
144#define GP_PIXEL_RGB888_TO_RGB888(p1, p2) \
145 GP_PIXEL_RGB888_TO_RGB888_OFFSET(p1, 0, p2, 0)
146
147/*
148 * Converts RGB888 -> BGR888
149 *
150 * macro reads p1 (RGB888 at bit-offset o1)
151 * and writes to p2 (BGR888 at bit-offset o2)
152 * the relevant part of p2 is assumed to be cleared (zero)
153 */
154#define GP_PIXEL_RGB888_TO_BGR888_OFFSET(p1, o1, p2, o2) do { \
155 /* B:=B */ GP_SET_BITS(16+o2, 8, p2,\
156 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
157 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
158 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
159 /* R:=R */ GP_SET_BITS(0+o2, 8, p2,\
160 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
161} while (0)
162
163/* a version without offsets */
164#define GP_PIXEL_RGB888_TO_BGR888(p1, p2) \
165 GP_PIXEL_RGB888_TO_BGR888_OFFSET(p1, 0, p2, 0)
166
167/*
168 * Converts BGR888 -> RGB888
169 *
170 * macro reads p1 (BGR888 at bit-offset o1)
171 * and writes to p2 (RGB888 at bit-offset o2)
172 * the relevant part of p2 is assumed to be cleared (zero)
173 */
174#define GP_PIXEL_BGR888_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
175 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
176 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
177 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
178 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
179 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
180 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
181} while (0)
182
183/* a version without offsets */
184#define GP_PIXEL_BGR888_TO_RGB888(p1, p2) \
185 GP_PIXEL_BGR888_TO_RGB888_OFFSET(p1, 0, p2, 0)
186
187/*
188 * Converts RGB888 -> RGB555
189 *
190 * macro reads p1 (RGB888 at bit-offset o1)
191 * and writes to p2 (RGB555 at bit-offset o2)
192 * the relevant part of p2 is assumed to be cleared (zero)
193 */
194#define GP_PIXEL_RGB888_TO_RGB555_OFFSET(p1, o1, p2, o2) do { \
195 /* R:=R */ GP_SET_BITS(10+o2, 5, p2,\
196 GP_SCALE_VAL_8_5(GP_GET_BITS(16+o1, 8, p1))); \
197 /* G:=G */ GP_SET_BITS(5+o2, 5, p2,\
198 GP_SCALE_VAL_8_5(GP_GET_BITS(8+o1, 8, p1))); \
199 /* B:=B */ GP_SET_BITS(0+o2, 5, p2,\
200 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
201} while (0)
202
203/* a version without offsets */
204#define GP_PIXEL_RGB888_TO_RGB555(p1, p2) \
205 GP_PIXEL_RGB888_TO_RGB555_OFFSET(p1, 0, p2, 0)
206
207/*
208 * Converts RGB555 -> RGB888
209 *
210 * macro reads p1 (RGB555 at bit-offset o1)
211 * and writes to p2 (RGB888 at bit-offset o2)
212 * the relevant part of p2 is assumed to be cleared (zero)
213 */
214#define GP_PIXEL_RGB555_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
215 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
216 GP_SCALE_VAL_5_8(GP_GET_BITS(10+o1, 5, p1))); \
217 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
218 GP_SCALE_VAL_5_8(GP_GET_BITS(5+o1, 5, p1))); \
219 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
220 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
221} while (0)
222
223/* a version without offsets */
224#define GP_PIXEL_RGB555_TO_RGB888(p1, p2) \
225 GP_PIXEL_RGB555_TO_RGB888_OFFSET(p1, 0, p2, 0)
226
227/*
228 * Converts RGB888 -> RGB565_BE
229 *
230 * macro reads p1 (RGB888 at bit-offset o1)
231 * and writes to p2 (RGB565_BE at bit-offset o2)
232 * the relevant part of p2 is assumed to be cleared (zero)
233 */
234#define GP_PIXEL_RGB888_TO_RGB565_BE_OFFSET(p1, o1, p2, o2) do { \
235 /* R:=R */ GP_SET_BITS(11+o2, 5, p2,\
236 GP_SCALE_VAL_8_5(GP_GET_BITS(16+o1, 8, p1))); \
237 /* G:=G */ GP_SET_BITS(5+o2, 6, p2,\
238 GP_SCALE_VAL_8_6(GP_GET_BITS(8+o1, 8, p1))); \
239 /* B:=B */ GP_SET_BITS(0+o2, 5, p2,\
240 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
241} while (0)
242
243/* a version without offsets */
244#define GP_PIXEL_RGB888_TO_RGB565_BE(p1, p2) \
245 GP_PIXEL_RGB888_TO_RGB565_BE_OFFSET(p1, 0, p2, 0)
246
247/*
248 * Converts RGB565_BE -> RGB888
249 *
250 * macro reads p1 (RGB565_BE at bit-offset o1)
251 * and writes to p2 (RGB888 at bit-offset o2)
252 * the relevant part of p2 is assumed to be cleared (zero)
253 */
254#define GP_PIXEL_RGB565_BE_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
255 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
256 GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1))); \
257 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
258 GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1))); \
259 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
260 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
261} while (0)
262
263/* a version without offsets */
264#define GP_PIXEL_RGB565_BE_TO_RGB888(p1, p2) \
265 GP_PIXEL_RGB565_BE_TO_RGB888_OFFSET(p1, 0, p2, 0)
266
267/*
268 * Converts RGB888 -> RGB565_LE
269 *
270 * macro reads p1 (RGB888 at bit-offset o1)
271 * and writes to p2 (RGB565_LE at bit-offset o2)
272 * the relevant part of p2 is assumed to be cleared (zero)
273 */
274#define GP_PIXEL_RGB888_TO_RGB565_LE_OFFSET(p1, o1, p2, o2) do { \
275 /* R:=R */ GP_SET_BITS(11+o2, 5, p2,\
276 GP_SCALE_VAL_8_5(GP_GET_BITS(16+o1, 8, p1))); \
277 /* G:=G */ GP_SET_BITS(5+o2, 6, p2,\
278 GP_SCALE_VAL_8_6(GP_GET_BITS(8+o1, 8, p1))); \
279 /* B:=B */ GP_SET_BITS(0+o2, 5, p2,\
280 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
281} while (0)
282
283/* a version without offsets */
284#define GP_PIXEL_RGB888_TO_RGB565_LE(p1, p2) \
285 GP_PIXEL_RGB888_TO_RGB565_LE_OFFSET(p1, 0, p2, 0)
286
287/*
288 * Converts RGB565_LE -> RGB888
289 *
290 * macro reads p1 (RGB565_LE at bit-offset o1)
291 * and writes to p2 (RGB888 at bit-offset o2)
292 * the relevant part of p2 is assumed to be cleared (zero)
293 */
294#define GP_PIXEL_RGB565_LE_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
295 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
296 GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1))); \
297 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
298 GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1))); \
299 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
300 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
301} while (0)
302
303/* a version without offsets */
304#define GP_PIXEL_RGB565_LE_TO_RGB888(p1, p2) \
305 GP_PIXEL_RGB565_LE_TO_RGB888_OFFSET(p1, 0, p2, 0)
306
307/*
308 * Converts RGB888 -> RGB666
309 *
310 * macro reads p1 (RGB888 at bit-offset o1)
311 * and writes to p2 (RGB666 at bit-offset o2)
312 * the relevant part of p2 is assumed to be cleared (zero)
313 */
314#define GP_PIXEL_RGB888_TO_RGB666_OFFSET(p1, o1, p2, o2) do { \
315 /* R:=R */ GP_SET_BITS(12+o2, 6, p2,\
316 GP_SCALE_VAL_8_6(GP_GET_BITS(16+o1, 8, p1))); \
317 /* G:=G */ GP_SET_BITS(6+o2, 6, p2,\
318 GP_SCALE_VAL_8_6(GP_GET_BITS(8+o1, 8, p1))); \
319 /* B:=B */ GP_SET_BITS(0+o2, 6, p2,\
320 GP_SCALE_VAL_8_6(GP_GET_BITS(0+o1, 8, p1))); \
321} while (0)
322
323/* a version without offsets */
324#define GP_PIXEL_RGB888_TO_RGB666(p1, p2) \
325 GP_PIXEL_RGB888_TO_RGB666_OFFSET(p1, 0, p2, 0)
326
327/*
328 * Converts RGB666 -> RGB888
329 *
330 * macro reads p1 (RGB666 at bit-offset o1)
331 * and writes to p2 (RGB888 at bit-offset o2)
332 * the relevant part of p2 is assumed to be cleared (zero)
333 */
334#define GP_PIXEL_RGB666_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
335 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
336 GP_SCALE_VAL_6_8(GP_GET_BITS(12+o1, 6, p1))); \
337 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
338 GP_SCALE_VAL_6_8(GP_GET_BITS(6+o1, 6, p1))); \
339 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
340 GP_SCALE_VAL_6_8(GP_GET_BITS(0+o1, 6, p1))); \
341} while (0)
342
343/* a version without offsets */
344#define GP_PIXEL_RGB666_TO_RGB888(p1, p2) \
345 GP_PIXEL_RGB666_TO_RGB888_OFFSET(p1, 0, p2, 0)
346
347/*
348 * Converts RGB888 -> RGB332
349 *
350 * macro reads p1 (RGB888 at bit-offset o1)
351 * and writes to p2 (RGB332 at bit-offset o2)
352 * the relevant part of p2 is assumed to be cleared (zero)
353 */
354#define GP_PIXEL_RGB888_TO_RGB332_OFFSET(p1, o1, p2, o2) do { \
355 /* R:=R */ GP_SET_BITS(5+o2, 3, p2,\
356 GP_SCALE_VAL_8_3(GP_GET_BITS(16+o1, 8, p1))); \
357 /* G:=G */ GP_SET_BITS(2+o2, 3, p2,\
358 GP_SCALE_VAL_8_3(GP_GET_BITS(8+o1, 8, p1))); \
359 /* B:=B */ GP_SET_BITS(0+o2, 2, p2,\
360 GP_SCALE_VAL_8_2(GP_GET_BITS(0+o1, 8, p1))); \
361} while (0)
362
363/* a version without offsets */
364#define GP_PIXEL_RGB888_TO_RGB332(p1, p2) \
365 GP_PIXEL_RGB888_TO_RGB332_OFFSET(p1, 0, p2, 0)
366
367/*
368 * Converts RGB332 -> RGB888
369 *
370 * macro reads p1 (RGB332 at bit-offset o1)
371 * and writes to p2 (RGB888 at bit-offset o2)
372 * the relevant part of p2 is assumed to be cleared (zero)
373 */
374#define GP_PIXEL_RGB332_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
375 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
376 GP_SCALE_VAL_3_8(GP_GET_BITS(5+o1, 3, p1))); \
377 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
378 GP_SCALE_VAL_3_8(GP_GET_BITS(2+o1, 3, p1))); \
379 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
380 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
381} while (0)
382
383/* a version without offsets */
384#define GP_PIXEL_RGB332_TO_RGB888(p1, p2) \
385 GP_PIXEL_RGB332_TO_RGB888_OFFSET(p1, 0, p2, 0)
386
387/*
388 * Converts RGB888 -> CMYK8888
389 *
390 * macro reads p1 (RGB888 at bit-offset o1)
391 * and writes to p2 (CMYK8888 at bit-offset o2)
392 * the relevant part of p2 is assumed to be cleared (zero)
393 */
394#define GP_PIXEL_RGB888_TO_CMYK8888_OFFSET(p1, o1, p2, o2) do { \
395 gp_pixel gp_r = GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)); \
396 gp_pixel gp_g = GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)); \
397 gp_pixel gp_b = GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1)); \
398 gp_pixel gp_k = GP_MAX3(gp_r, gp_g, gp_b); \
399 GP_SET_BITS(0+o2, 8, p2, GP_SCALE_VAL_8_8((gp_k - gp_r))); \
400 GP_SET_BITS(8+o2, 8, p2, GP_SCALE_VAL_8_8((gp_k - gp_g))); \
401 GP_SET_BITS(16+o2, 8, p2, GP_SCALE_VAL_8_8((gp_k - gp_b))); \
402 GP_SET_BITS(24+o2, 8, p2, GP_SCALE_VAL_8_8(255 - gp_k)); \
403} while (0)
404
405/* a version without offsets */
406#define GP_PIXEL_RGB888_TO_CMYK8888(p1, p2) \
407 GP_PIXEL_RGB888_TO_CMYK8888_OFFSET(p1, 0, p2, 0)
408
409/*
410 * Converts CMYK8888 -> RGB888
411 *
412 * macro reads p1 (CMYK8888 at bit-offset o1)
413 * and writes to p2 (RGB888 at bit-offset o2)
414 * the relevant part of p2 is assumed to be cleared (zero)
415 */
416#define GP_PIXEL_CMYK8888_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
417 GP_SET_BITS(16+o2, 8, p2,\
418 ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
419 (0xff - GP_GET_BITS(0+o1, 8, p1)))) / (0xff * 0xff) \
420 ); \
421 GP_SET_BITS(8+o2, 8, p2,\
422 ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
423 (0xff - GP_GET_BITS(8+o1, 8, p1)))) / (0xff * 0xff) \
424 ); \
425 GP_SET_BITS(0+o2, 8, p2,\
426 ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
427 (0xff - GP_GET_BITS(16+o1, 8, p1)))) / (0xff * 0xff) \
428 ); \
429} while (0)
430
431/* a version without offsets */
432#define GP_PIXEL_CMYK8888_TO_RGB888(p1, p2) \
433 GP_PIXEL_CMYK8888_TO_RGB888_OFFSET(p1, 0, p2, 0)
434
435/*
436 * Converts RGB888 -> G1_DB
437 *
438 * macro reads p1 (RGB888 at bit-offset o1)
439 * and writes to p2 (G1_DB at bit-offset o2)
440 * the relevant part of p2 is assumed to be cleared (zero)
441 */
442#define GP_PIXEL_RGB888_TO_G1_DB_OFFSET(p1, o1, p2, o2) do { \
443 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 1, p2, ( \
444 /* R */ GP_SCALE_VAL_8_1(GP_GET_BITS(16+o1, 8, p1)) + \
445 /* G */ GP_SCALE_VAL_8_1(GP_GET_BITS(8+o1, 8, p1)) + \
446 /* B */ GP_SCALE_VAL_8_1(GP_GET_BITS(0+o1, 8, p1)) + \
447 0)/3);\
448} while (0)
449
450/* a version without offsets */
451#define GP_PIXEL_RGB888_TO_G1_DB(p1, p2) \
452 GP_PIXEL_RGB888_TO_G1_DB_OFFSET(p1, 0, p2, 0)
453
454/*
455 * Converts G1_DB -> RGB888
456 *
457 * macro reads p1 (G1_DB at bit-offset o1)
458 * and writes to p2 (RGB888 at bit-offset o2)
459 * the relevant part of p2 is assumed to be cleared (zero)
460 */
461#define GP_PIXEL_G1_DB_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
462 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
463 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
464 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
465 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
466 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
467 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
468} while (0)
469
470/* a version without offsets */
471#define GP_PIXEL_G1_DB_TO_RGB888(p1, p2) \
472 GP_PIXEL_G1_DB_TO_RGB888_OFFSET(p1, 0, p2, 0)
473
474/*
475 * Converts RGB888 -> G2_DB
476 *
477 * macro reads p1 (RGB888 at bit-offset o1)
478 * and writes to p2 (G2_DB at bit-offset o2)
479 * the relevant part of p2 is assumed to be cleared (zero)
480 */
481#define GP_PIXEL_RGB888_TO_G2_DB_OFFSET(p1, o1, p2, o2) do { \
482 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 2, p2, ( \
483 /* R */ GP_SCALE_VAL_8_2(GP_GET_BITS(16+o1, 8, p1)) + \
484 /* G */ GP_SCALE_VAL_8_2(GP_GET_BITS(8+o1, 8, p1)) + \
485 /* B */ GP_SCALE_VAL_8_2(GP_GET_BITS(0+o1, 8, p1)) + \
486 0)/3);\
487} while (0)
488
489/* a version without offsets */
490#define GP_PIXEL_RGB888_TO_G2_DB(p1, p2) \
491 GP_PIXEL_RGB888_TO_G2_DB_OFFSET(p1, 0, p2, 0)
492
493/*
494 * Converts G2_DB -> RGB888
495 *
496 * macro reads p1 (G2_DB at bit-offset o1)
497 * and writes to p2 (RGB888 at bit-offset o2)
498 * the relevant part of p2 is assumed to be cleared (zero)
499 */
500#define GP_PIXEL_G2_DB_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
501 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
502 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
503 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
504 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
505 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
506 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
507} while (0)
508
509/* a version without offsets */
510#define GP_PIXEL_G2_DB_TO_RGB888(p1, p2) \
511 GP_PIXEL_G2_DB_TO_RGB888_OFFSET(p1, 0, p2, 0)
512
513/*
514 * Converts RGB888 -> G4_DB
515 *
516 * macro reads p1 (RGB888 at bit-offset o1)
517 * and writes to p2 (G4_DB at bit-offset o2)
518 * the relevant part of p2 is assumed to be cleared (zero)
519 */
520#define GP_PIXEL_RGB888_TO_G4_DB_OFFSET(p1, o1, p2, o2) do { \
521 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 4, p2, ( \
522 /* R */ GP_SCALE_VAL_8_4(GP_GET_BITS(16+o1, 8, p1)) + \
523 /* G */ GP_SCALE_VAL_8_4(GP_GET_BITS(8+o1, 8, p1)) + \
524 /* B */ GP_SCALE_VAL_8_4(GP_GET_BITS(0+o1, 8, p1)) + \
525 0)/3);\
526} while (0)
527
528/* a version without offsets */
529#define GP_PIXEL_RGB888_TO_G4_DB(p1, p2) \
530 GP_PIXEL_RGB888_TO_G4_DB_OFFSET(p1, 0, p2, 0)
531
532/*
533 * Converts G4_DB -> RGB888
534 *
535 * macro reads p1 (G4_DB at bit-offset o1)
536 * and writes to p2 (RGB888 at bit-offset o2)
537 * the relevant part of p2 is assumed to be cleared (zero)
538 */
539#define GP_PIXEL_G4_DB_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
540 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
541 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
542 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
543 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
544 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
545 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
546} while (0)
547
548/* a version without offsets */
549#define GP_PIXEL_G4_DB_TO_RGB888(p1, p2) \
550 GP_PIXEL_G4_DB_TO_RGB888_OFFSET(p1, 0, p2, 0)
551
552/*
553 * Converts RGB888 -> G1_UB
554 *
555 * macro reads p1 (RGB888 at bit-offset o1)
556 * and writes to p2 (G1_UB at bit-offset o2)
557 * the relevant part of p2 is assumed to be cleared (zero)
558 */
559#define GP_PIXEL_RGB888_TO_G1_UB_OFFSET(p1, o1, p2, o2) do { \
560 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 1, p2, ( \
561 /* R */ GP_SCALE_VAL_8_1(GP_GET_BITS(16+o1, 8, p1)) + \
562 /* G */ GP_SCALE_VAL_8_1(GP_GET_BITS(8+o1, 8, p1)) + \
563 /* B */ GP_SCALE_VAL_8_1(GP_GET_BITS(0+o1, 8, p1)) + \
564 0)/3);\
565} while (0)
566
567/* a version without offsets */
568#define GP_PIXEL_RGB888_TO_G1_UB(p1, p2) \
569 GP_PIXEL_RGB888_TO_G1_UB_OFFSET(p1, 0, p2, 0)
570
571/*
572 * Converts G1_UB -> RGB888
573 *
574 * macro reads p1 (G1_UB at bit-offset o1)
575 * and writes to p2 (RGB888 at bit-offset o2)
576 * the relevant part of p2 is assumed to be cleared (zero)
577 */
578#define GP_PIXEL_G1_UB_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
579 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
580 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
581 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
582 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
583 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
584 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
585} while (0)
586
587/* a version without offsets */
588#define GP_PIXEL_G1_UB_TO_RGB888(p1, p2) \
589 GP_PIXEL_G1_UB_TO_RGB888_OFFSET(p1, 0, p2, 0)
590
591/*
592 * Converts RGB888 -> G2_UB
593 *
594 * macro reads p1 (RGB888 at bit-offset o1)
595 * and writes to p2 (G2_UB at bit-offset o2)
596 * the relevant part of p2 is assumed to be cleared (zero)
597 */
598#define GP_PIXEL_RGB888_TO_G2_UB_OFFSET(p1, o1, p2, o2) do { \
599 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 2, p2, ( \
600 /* R */ GP_SCALE_VAL_8_2(GP_GET_BITS(16+o1, 8, p1)) + \
601 /* G */ GP_SCALE_VAL_8_2(GP_GET_BITS(8+o1, 8, p1)) + \
602 /* B */ GP_SCALE_VAL_8_2(GP_GET_BITS(0+o1, 8, p1)) + \
603 0)/3);\
604} while (0)
605
606/* a version without offsets */
607#define GP_PIXEL_RGB888_TO_G2_UB(p1, p2) \
608 GP_PIXEL_RGB888_TO_G2_UB_OFFSET(p1, 0, p2, 0)
609
610/*
611 * Converts G2_UB -> RGB888
612 *
613 * macro reads p1 (G2_UB at bit-offset o1)
614 * and writes to p2 (RGB888 at bit-offset o2)
615 * the relevant part of p2 is assumed to be cleared (zero)
616 */
617#define GP_PIXEL_G2_UB_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
618 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
619 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
620 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
621 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
622 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
623 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
624} while (0)
625
626/* a version without offsets */
627#define GP_PIXEL_G2_UB_TO_RGB888(p1, p2) \
628 GP_PIXEL_G2_UB_TO_RGB888_OFFSET(p1, 0, p2, 0)
629
630/*
631 * Converts RGB888 -> G4_UB
632 *
633 * macro reads p1 (RGB888 at bit-offset o1)
634 * and writes to p2 (G4_UB at bit-offset o2)
635 * the relevant part of p2 is assumed to be cleared (zero)
636 */
637#define GP_PIXEL_RGB888_TO_G4_UB_OFFSET(p1, o1, p2, o2) do { \
638 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 4, p2, ( \
639 /* R */ GP_SCALE_VAL_8_4(GP_GET_BITS(16+o1, 8, p1)) + \
640 /* G */ GP_SCALE_VAL_8_4(GP_GET_BITS(8+o1, 8, p1)) + \
641 /* B */ GP_SCALE_VAL_8_4(GP_GET_BITS(0+o1, 8, p1)) + \
642 0)/3);\
643} while (0)
644
645/* a version without offsets */
646#define GP_PIXEL_RGB888_TO_G4_UB(p1, p2) \
647 GP_PIXEL_RGB888_TO_G4_UB_OFFSET(p1, 0, p2, 0)
648
649/*
650 * Converts G4_UB -> RGB888
651 *
652 * macro reads p1 (G4_UB at bit-offset o1)
653 * and writes to p2 (RGB888 at bit-offset o2)
654 * the relevant part of p2 is assumed to be cleared (zero)
655 */
656#define GP_PIXEL_G4_UB_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
657 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
658 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
659 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
660 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
661 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
662 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
663} while (0)
664
665/* a version without offsets */
666#define GP_PIXEL_G4_UB_TO_RGB888(p1, p2) \
667 GP_PIXEL_G4_UB_TO_RGB888_OFFSET(p1, 0, p2, 0)
668
669/*
670 * Converts RGB888 -> G8
671 *
672 * macro reads p1 (RGB888 at bit-offset o1)
673 * and writes to p2 (G8 at bit-offset o2)
674 * the relevant part of p2 is assumed to be cleared (zero)
675 */
676#define GP_PIXEL_RGB888_TO_G8_OFFSET(p1, o1, p2, o2) do { \
677 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
678 /* R */ GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)) + \
679 /* G */ GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)) + \
680 /* B */ GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1)) + \
681 0)/3);\
682} while (0)
683
684/* a version without offsets */
685#define GP_PIXEL_RGB888_TO_G8(p1, p2) \
686 GP_PIXEL_RGB888_TO_G8_OFFSET(p1, 0, p2, 0)
687
688/*
689 * Converts RGB888 -> GA88
690 *
691 * macro reads p1 (RGB888 at bit-offset o1)
692 * and writes to p2 (GA88 at bit-offset o2)
693 * the relevant part of p2 is assumed to be cleared (zero)
694 */
695#define GP_PIXEL_RGB888_TO_GA88_OFFSET(p1, o1, p2, o2) do { \
696 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
697 /* R */ GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)) + \
698 /* G */ GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)) + \
699 /* B */ GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1)) + \
700 0)/3);\
701 /* A:=0xff */GP_SET_BITS(8+o2, 8, p2, 0xff); \
702} while (0)
703
704/* a version without offsets */
705#define GP_PIXEL_RGB888_TO_GA88(p1, p2) \
706 GP_PIXEL_RGB888_TO_GA88_OFFSET(p1, 0, p2, 0)
707
708/*
709 * Converts GA88 -> RGB888
710 *
711 * macro reads p1 (GA88 at bit-offset o1)
712 * and writes to p2 (RGB888 at bit-offset o2)
713 * the relevant part of p2 is assumed to be cleared (zero)
714 */
715#define GP_PIXEL_GA88_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
716 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
717 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
718 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
719 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
720 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
721 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
722} while (0)
723
724/* a version without offsets */
725#define GP_PIXEL_GA88_TO_RGB888(p1, p2) \
726 GP_PIXEL_GA88_TO_RGB888_OFFSET(p1, 0, p2, 0)
727
728/*
729 * Converts RGB888 -> G16
730 *
731 * macro reads p1 (RGB888 at bit-offset o1)
732 * and writes to p2 (G16 at bit-offset o2)
733 * the relevant part of p2 is assumed to be cleared (zero)
734 */
735#define GP_PIXEL_RGB888_TO_G16_OFFSET(p1, o1, p2, o2) do { \
736 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 16, p2, ( \
737 /* R */ GP_SCALE_VAL_8_16(GP_GET_BITS(16+o1, 8, p1)) + \
738 /* G */ GP_SCALE_VAL_8_16(GP_GET_BITS(8+o1, 8, p1)) + \
739 /* B */ GP_SCALE_VAL_8_16(GP_GET_BITS(0+o1, 8, p1)) + \
740 0)/3);\
741} while (0)
742
743/* a version without offsets */
744#define GP_PIXEL_RGB888_TO_G16(p1, p2) \
745 GP_PIXEL_RGB888_TO_G16_OFFSET(p1, 0, p2, 0)
746
747/*
748 * Converts G16 -> RGB888
749 *
750 * macro reads p1 (G16 at bit-offset o1)
751 * and writes to p2 (RGB888 at bit-offset o2)
752 * the relevant part of p2 is assumed to be cleared (zero)
753 */
754#define GP_PIXEL_G16_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
755 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
756 GP_SCALE_VAL_16_8(GP_GET_BITS(0+o1, 16, p1))); \
757 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
758 GP_SCALE_VAL_16_8(GP_GET_BITS(0+o1, 16, p1))); \
759 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
760 GP_SCALE_VAL_16_8(GP_GET_BITS(0+o1, 16, p1))); \
761} while (0)
762
763/* a version without offsets */
764#define GP_PIXEL_G16_TO_RGB888(p1, p2) \
765 GP_PIXEL_G16_TO_RGB888_OFFSET(p1, 0, p2, 0)
766
767
778gp_pixel gp_RGB888_to_pixel(gp_pixel pixel, gp_pixel_type type);
779
790gp_pixel gp_pixel_to_RGB888(gp_pixel pixel, gp_pixel_type type);
791
792/*
793 * Converts RGBA8888 -> RGB101010
794 *
795 * macro reads p1 (RGBA8888 at bit-offset o1)
796 * and writes to p2 (RGB101010 at bit-offset o2)
797 * the relevant part of p2 is assumed to be cleared (zero)
798 */
799#define GP_PIXEL_RGBA8888_TO_RGB101010_OFFSET(p1, o1, p2, o2) do { \
800 /* R:=R */ GP_SET_BITS(20+o2, 10, p2,\
801 GP_SCALE_VAL_8_10(GP_GET_BITS(24+o1, 8, p1))); \
802 /* G:=G */ GP_SET_BITS(10+o2, 10, p2,\
803 GP_SCALE_VAL_8_10(GP_GET_BITS(16+o1, 8, p1))); \
804 /* B:=B */ GP_SET_BITS(0+o2, 10, p2,\
805 GP_SCALE_VAL_8_10(GP_GET_BITS(8+o1, 8, p1))); \
806} while (0)
807
808/* a version without offsets */
809#define GP_PIXEL_RGBA8888_TO_RGB101010(p1, p2) \
810 GP_PIXEL_RGBA8888_TO_RGB101010_OFFSET(p1, 0, p2, 0)
811
812/*
813 * Converts RGB101010 -> RGBA8888
814 *
815 * macro reads p1 (RGB101010 at bit-offset o1)
816 * and writes to p2 (RGBA8888 at bit-offset o2)
817 * the relevant part of p2 is assumed to be cleared (zero)
818 */
819#define GP_PIXEL_RGB101010_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
820 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
821 GP_SCALE_VAL_10_8(GP_GET_BITS(20+o1, 10, p1))); \
822 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
823 GP_SCALE_VAL_10_8(GP_GET_BITS(10+o1, 10, p1))); \
824 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
825 GP_SCALE_VAL_10_8(GP_GET_BITS(0+o1, 10, p1))); \
826 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
827} while (0)
828
829/* a version without offsets */
830#define GP_PIXEL_RGB101010_TO_RGBA8888(p1, p2) \
831 GP_PIXEL_RGB101010_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
832
833/*
834 * Converts RGBA8888 -> xRGB8888
835 *
836 * macro reads p1 (RGBA8888 at bit-offset o1)
837 * and writes to p2 (xRGB8888 at bit-offset o2)
838 * the relevant part of p2 is assumed to be cleared (zero)
839 */
840#define GP_PIXEL_RGBA8888_TO_xRGB8888_OFFSET(p1, o1, p2, o2) do { \
841 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
842 GP_SCALE_VAL_8_8(GP_GET_BITS(24+o1, 8, p1))); \
843 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
844 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
845 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
846 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
847} while (0)
848
849/* a version without offsets */
850#define GP_PIXEL_RGBA8888_TO_xRGB8888(p1, p2) \
851 GP_PIXEL_RGBA8888_TO_xRGB8888_OFFSET(p1, 0, p2, 0)
852
853/*
854 * Converts xRGB8888 -> RGBA8888
855 *
856 * macro reads p1 (xRGB8888 at bit-offset o1)
857 * and writes to p2 (RGBA8888 at bit-offset o2)
858 * the relevant part of p2 is assumed to be cleared (zero)
859 */
860#define GP_PIXEL_xRGB8888_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
861 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
862 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
863 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
864 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
865 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
866 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
867 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
868} while (0)
869
870/* a version without offsets */
871#define GP_PIXEL_xRGB8888_TO_RGBA8888(p1, p2) \
872 GP_PIXEL_xRGB8888_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
873
874/*
875 * Converts RGBA8888 -> RGBA8888
876 *
877 * macro reads p1 (RGBA8888 at bit-offset o1)
878 * and writes to p2 (RGBA8888 at bit-offset o2)
879 * the relevant part of p2 is assumed to be cleared (zero)
880 */
881#define GP_PIXEL_RGBA8888_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
882 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
883 GP_SCALE_VAL_8_8(GP_GET_BITS(24+o1, 8, p1))); \
884 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
885 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
886 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
887 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
888 /* A:=A */ GP_SET_BITS(0+o2, 8, p2,\
889 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
890} while (0)
891
892/* a version without offsets */
893#define GP_PIXEL_RGBA8888_TO_RGBA8888(p1, p2) \
894 GP_PIXEL_RGBA8888_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
895
896/*
897 * Converts RGBA8888 -> RGB888
898 *
899 * macro reads p1 (RGBA8888 at bit-offset o1)
900 * and writes to p2 (RGB888 at bit-offset o2)
901 * the relevant part of p2 is assumed to be cleared (zero)
902 */
903#define GP_PIXEL_RGBA8888_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
904 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
905 GP_SCALE_VAL_8_8(GP_GET_BITS(24+o1, 8, p1))); \
906 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
907 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
908 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
909 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
910} while (0)
911
912/* a version without offsets */
913#define GP_PIXEL_RGBA8888_TO_RGB888(p1, p2) \
914 GP_PIXEL_RGBA8888_TO_RGB888_OFFSET(p1, 0, p2, 0)
915
916/*
917 * Converts RGBA8888 -> BGR888
918 *
919 * macro reads p1 (RGBA8888 at bit-offset o1)
920 * and writes to p2 (BGR888 at bit-offset o2)
921 * the relevant part of p2 is assumed to be cleared (zero)
922 */
923#define GP_PIXEL_RGBA8888_TO_BGR888_OFFSET(p1, o1, p2, o2) do { \
924 /* B:=B */ GP_SET_BITS(16+o2, 8, p2,\
925 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
926 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
927 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
928 /* R:=R */ GP_SET_BITS(0+o2, 8, p2,\
929 GP_SCALE_VAL_8_8(GP_GET_BITS(24+o1, 8, p1))); \
930} while (0)
931
932/* a version without offsets */
933#define GP_PIXEL_RGBA8888_TO_BGR888(p1, p2) \
934 GP_PIXEL_RGBA8888_TO_BGR888_OFFSET(p1, 0, p2, 0)
935
936/*
937 * Converts BGR888 -> RGBA8888
938 *
939 * macro reads p1 (BGR888 at bit-offset o1)
940 * and writes to p2 (RGBA8888 at bit-offset o2)
941 * the relevant part of p2 is assumed to be cleared (zero)
942 */
943#define GP_PIXEL_BGR888_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
944 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
945 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
946 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
947 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
948 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
949 GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1))); \
950 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
951} while (0)
952
953/* a version without offsets */
954#define GP_PIXEL_BGR888_TO_RGBA8888(p1, p2) \
955 GP_PIXEL_BGR888_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
956
957/*
958 * Converts RGBA8888 -> RGB555
959 *
960 * macro reads p1 (RGBA8888 at bit-offset o1)
961 * and writes to p2 (RGB555 at bit-offset o2)
962 * the relevant part of p2 is assumed to be cleared (zero)
963 */
964#define GP_PIXEL_RGBA8888_TO_RGB555_OFFSET(p1, o1, p2, o2) do { \
965 /* R:=R */ GP_SET_BITS(10+o2, 5, p2,\
966 GP_SCALE_VAL_8_5(GP_GET_BITS(24+o1, 8, p1))); \
967 /* G:=G */ GP_SET_BITS(5+o2, 5, p2,\
968 GP_SCALE_VAL_8_5(GP_GET_BITS(16+o1, 8, p1))); \
969 /* B:=B */ GP_SET_BITS(0+o2, 5, p2,\
970 GP_SCALE_VAL_8_5(GP_GET_BITS(8+o1, 8, p1))); \
971} while (0)
972
973/* a version without offsets */
974#define GP_PIXEL_RGBA8888_TO_RGB555(p1, p2) \
975 GP_PIXEL_RGBA8888_TO_RGB555_OFFSET(p1, 0, p2, 0)
976
977/*
978 * Converts RGB555 -> RGBA8888
979 *
980 * macro reads p1 (RGB555 at bit-offset o1)
981 * and writes to p2 (RGBA8888 at bit-offset o2)
982 * the relevant part of p2 is assumed to be cleared (zero)
983 */
984#define GP_PIXEL_RGB555_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
985 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
986 GP_SCALE_VAL_5_8(GP_GET_BITS(10+o1, 5, p1))); \
987 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
988 GP_SCALE_VAL_5_8(GP_GET_BITS(5+o1, 5, p1))); \
989 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
990 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
991 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
992} while (0)
993
994/* a version without offsets */
995#define GP_PIXEL_RGB555_TO_RGBA8888(p1, p2) \
996 GP_PIXEL_RGB555_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
997
998/*
999 * Converts RGBA8888 -> RGB565_BE
1000 *
1001 * macro reads p1 (RGBA8888 at bit-offset o1)
1002 * and writes to p2 (RGB565_BE at bit-offset o2)
1003 * the relevant part of p2 is assumed to be cleared (zero)
1004 */
1005#define GP_PIXEL_RGBA8888_TO_RGB565_BE_OFFSET(p1, o1, p2, o2) do { \
1006 /* R:=R */ GP_SET_BITS(11+o2, 5, p2,\
1007 GP_SCALE_VAL_8_5(GP_GET_BITS(24+o1, 8, p1))); \
1008 /* G:=G */ GP_SET_BITS(5+o2, 6, p2,\
1009 GP_SCALE_VAL_8_6(GP_GET_BITS(16+o1, 8, p1))); \
1010 /* B:=B */ GP_SET_BITS(0+o2, 5, p2,\
1011 GP_SCALE_VAL_8_5(GP_GET_BITS(8+o1, 8, p1))); \
1012} while (0)
1013
1014/* a version without offsets */
1015#define GP_PIXEL_RGBA8888_TO_RGB565_BE(p1, p2) \
1016 GP_PIXEL_RGBA8888_TO_RGB565_BE_OFFSET(p1, 0, p2, 0)
1017
1018/*
1019 * Converts RGB565_BE -> RGBA8888
1020 *
1021 * macro reads p1 (RGB565_BE at bit-offset o1)
1022 * and writes to p2 (RGBA8888 at bit-offset o2)
1023 * the relevant part of p2 is assumed to be cleared (zero)
1024 */
1025#define GP_PIXEL_RGB565_BE_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1026 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
1027 GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1))); \
1028 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
1029 GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1))); \
1030 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
1031 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
1032 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1033} while (0)
1034
1035/* a version without offsets */
1036#define GP_PIXEL_RGB565_BE_TO_RGBA8888(p1, p2) \
1037 GP_PIXEL_RGB565_BE_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1038
1039/*
1040 * Converts RGBA8888 -> RGB565_LE
1041 *
1042 * macro reads p1 (RGBA8888 at bit-offset o1)
1043 * and writes to p2 (RGB565_LE at bit-offset o2)
1044 * the relevant part of p2 is assumed to be cleared (zero)
1045 */
1046#define GP_PIXEL_RGBA8888_TO_RGB565_LE_OFFSET(p1, o1, p2, o2) do { \
1047 /* R:=R */ GP_SET_BITS(11+o2, 5, p2,\
1048 GP_SCALE_VAL_8_5(GP_GET_BITS(24+o1, 8, p1))); \
1049 /* G:=G */ GP_SET_BITS(5+o2, 6, p2,\
1050 GP_SCALE_VAL_8_6(GP_GET_BITS(16+o1, 8, p1))); \
1051 /* B:=B */ GP_SET_BITS(0+o2, 5, p2,\
1052 GP_SCALE_VAL_8_5(GP_GET_BITS(8+o1, 8, p1))); \
1053} while (0)
1054
1055/* a version without offsets */
1056#define GP_PIXEL_RGBA8888_TO_RGB565_LE(p1, p2) \
1057 GP_PIXEL_RGBA8888_TO_RGB565_LE_OFFSET(p1, 0, p2, 0)
1058
1059/*
1060 * Converts RGB565_LE -> RGBA8888
1061 *
1062 * macro reads p1 (RGB565_LE at bit-offset o1)
1063 * and writes to p2 (RGBA8888 at bit-offset o2)
1064 * the relevant part of p2 is assumed to be cleared (zero)
1065 */
1066#define GP_PIXEL_RGB565_LE_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1067 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
1068 GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1))); \
1069 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
1070 GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1))); \
1071 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
1072 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
1073 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1074} while (0)
1075
1076/* a version without offsets */
1077#define GP_PIXEL_RGB565_LE_TO_RGBA8888(p1, p2) \
1078 GP_PIXEL_RGB565_LE_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1079
1080/*
1081 * Converts RGBA8888 -> RGB666
1082 *
1083 * macro reads p1 (RGBA8888 at bit-offset o1)
1084 * and writes to p2 (RGB666 at bit-offset o2)
1085 * the relevant part of p2 is assumed to be cleared (zero)
1086 */
1087#define GP_PIXEL_RGBA8888_TO_RGB666_OFFSET(p1, o1, p2, o2) do { \
1088 /* R:=R */ GP_SET_BITS(12+o2, 6, p2,\
1089 GP_SCALE_VAL_8_6(GP_GET_BITS(24+o1, 8, p1))); \
1090 /* G:=G */ GP_SET_BITS(6+o2, 6, p2,\
1091 GP_SCALE_VAL_8_6(GP_GET_BITS(16+o1, 8, p1))); \
1092 /* B:=B */ GP_SET_BITS(0+o2, 6, p2,\
1093 GP_SCALE_VAL_8_6(GP_GET_BITS(8+o1, 8, p1))); \
1094} while (0)
1095
1096/* a version without offsets */
1097#define GP_PIXEL_RGBA8888_TO_RGB666(p1, p2) \
1098 GP_PIXEL_RGBA8888_TO_RGB666_OFFSET(p1, 0, p2, 0)
1099
1100/*
1101 * Converts RGB666 -> RGBA8888
1102 *
1103 * macro reads p1 (RGB666 at bit-offset o1)
1104 * and writes to p2 (RGBA8888 at bit-offset o2)
1105 * the relevant part of p2 is assumed to be cleared (zero)
1106 */
1107#define GP_PIXEL_RGB666_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1108 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
1109 GP_SCALE_VAL_6_8(GP_GET_BITS(12+o1, 6, p1))); \
1110 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
1111 GP_SCALE_VAL_6_8(GP_GET_BITS(6+o1, 6, p1))); \
1112 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
1113 GP_SCALE_VAL_6_8(GP_GET_BITS(0+o1, 6, p1))); \
1114 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1115} while (0)
1116
1117/* a version without offsets */
1118#define GP_PIXEL_RGB666_TO_RGBA8888(p1, p2) \
1119 GP_PIXEL_RGB666_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1120
1121/*
1122 * Converts RGBA8888 -> RGB332
1123 *
1124 * macro reads p1 (RGBA8888 at bit-offset o1)
1125 * and writes to p2 (RGB332 at bit-offset o2)
1126 * the relevant part of p2 is assumed to be cleared (zero)
1127 */
1128#define GP_PIXEL_RGBA8888_TO_RGB332_OFFSET(p1, o1, p2, o2) do { \
1129 /* R:=R */ GP_SET_BITS(5+o2, 3, p2,\
1130 GP_SCALE_VAL_8_3(GP_GET_BITS(24+o1, 8, p1))); \
1131 /* G:=G */ GP_SET_BITS(2+o2, 3, p2,\
1132 GP_SCALE_VAL_8_3(GP_GET_BITS(16+o1, 8, p1))); \
1133 /* B:=B */ GP_SET_BITS(0+o2, 2, p2,\
1134 GP_SCALE_VAL_8_2(GP_GET_BITS(8+o1, 8, p1))); \
1135} while (0)
1136
1137/* a version without offsets */
1138#define GP_PIXEL_RGBA8888_TO_RGB332(p1, p2) \
1139 GP_PIXEL_RGBA8888_TO_RGB332_OFFSET(p1, 0, p2, 0)
1140
1141/*
1142 * Converts RGB332 -> RGBA8888
1143 *
1144 * macro reads p1 (RGB332 at bit-offset o1)
1145 * and writes to p2 (RGBA8888 at bit-offset o2)
1146 * the relevant part of p2 is assumed to be cleared (zero)
1147 */
1148#define GP_PIXEL_RGB332_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1149 /* R:=R */ GP_SET_BITS(24+o2, 8, p2,\
1150 GP_SCALE_VAL_3_8(GP_GET_BITS(5+o1, 3, p1))); \
1151 /* G:=G */ GP_SET_BITS(16+o2, 8, p2,\
1152 GP_SCALE_VAL_3_8(GP_GET_BITS(2+o1, 3, p1))); \
1153 /* B:=B */ GP_SET_BITS(8+o2, 8, p2,\
1154 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
1155 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1156} while (0)
1157
1158/* a version without offsets */
1159#define GP_PIXEL_RGB332_TO_RGBA8888(p1, p2) \
1160 GP_PIXEL_RGB332_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1161
1162/*
1163 * Converts RGBA8888 -> CMYK8888
1164 *
1165 * macro reads p1 (RGBA8888 at bit-offset o1)
1166 * and writes to p2 (CMYK8888 at bit-offset o2)
1167 * the relevant part of p2 is assumed to be cleared (zero)
1168 */
1169#define GP_PIXEL_RGBA8888_TO_CMYK8888_OFFSET(p1, o1, p2, o2) do { \
1170 gp_pixel gp_r = GP_SCALE_VAL_8_8(GP_GET_BITS(24+o1, 8, p1)); \
1171 gp_pixel gp_g = GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)); \
1172 gp_pixel gp_b = GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)); \
1173 gp_pixel gp_k = GP_MAX3(gp_r, gp_g, gp_b); \
1174 GP_SET_BITS(0+o2, 8, p2, GP_SCALE_VAL_8_8((gp_k - gp_r))); \
1175 GP_SET_BITS(8+o2, 8, p2, GP_SCALE_VAL_8_8((gp_k - gp_g))); \
1176 GP_SET_BITS(16+o2, 8, p2, GP_SCALE_VAL_8_8((gp_k - gp_b))); \
1177 GP_SET_BITS(24+o2, 8, p2, GP_SCALE_VAL_8_8(255 - gp_k)); \
1178} while (0)
1179
1180/* a version without offsets */
1181#define GP_PIXEL_RGBA8888_TO_CMYK8888(p1, p2) \
1182 GP_PIXEL_RGBA8888_TO_CMYK8888_OFFSET(p1, 0, p2, 0)
1183
1184/*
1185 * Converts CMYK8888 -> RGBA8888
1186 *
1187 * macro reads p1 (CMYK8888 at bit-offset o1)
1188 * and writes to p2 (RGBA8888 at bit-offset o2)
1189 * the relevant part of p2 is assumed to be cleared (zero)
1190 */
1191#define GP_PIXEL_CMYK8888_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1192 GP_SET_BITS(24+o2, 8, p2,\
1193 ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
1194 (0xff - GP_GET_BITS(0+o1, 8, p1)))) / (0xff * 0xff) \
1195 ); \
1196 GP_SET_BITS(16+o2, 8, p2,\
1197 ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
1198 (0xff - GP_GET_BITS(8+o1, 8, p1)))) / (0xff * 0xff) \
1199 ); \
1200 GP_SET_BITS(8+o2, 8, p2,\
1201 ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
1202 (0xff - GP_GET_BITS(16+o1, 8, p1)))) / (0xff * 0xff) \
1203 ); \
1204 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1205} while (0)
1206
1207/* a version without offsets */
1208#define GP_PIXEL_CMYK8888_TO_RGBA8888(p1, p2) \
1209 GP_PIXEL_CMYK8888_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1210
1211/*
1212 * Converts RGBA8888 -> G1_DB
1213 *
1214 * macro reads p1 (RGBA8888 at bit-offset o1)
1215 * and writes to p2 (G1_DB at bit-offset o2)
1216 * the relevant part of p2 is assumed to be cleared (zero)
1217 */
1218#define GP_PIXEL_RGBA8888_TO_G1_DB_OFFSET(p1, o1, p2, o2) do { \
1219 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 1, p2, ( \
1220 /* R */ GP_SCALE_VAL_8_1(GP_GET_BITS(24+o1, 8, p1)) + \
1221 /* G */ GP_SCALE_VAL_8_1(GP_GET_BITS(16+o1, 8, p1)) + \
1222 /* B */ GP_SCALE_VAL_8_1(GP_GET_BITS(8+o1, 8, p1)) + \
1223 0)/3);\
1224} while (0)
1225
1226/* a version without offsets */
1227#define GP_PIXEL_RGBA8888_TO_G1_DB(p1, p2) \
1228 GP_PIXEL_RGBA8888_TO_G1_DB_OFFSET(p1, 0, p2, 0)
1229
1230/*
1231 * Converts G1_DB -> RGBA8888
1232 *
1233 * macro reads p1 (G1_DB at bit-offset o1)
1234 * and writes to p2 (RGBA8888 at bit-offset o2)
1235 * the relevant part of p2 is assumed to be cleared (zero)
1236 */
1237#define GP_PIXEL_G1_DB_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1238 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1239 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
1240 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1241 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
1242 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1243 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
1244 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1245} while (0)
1246
1247/* a version without offsets */
1248#define GP_PIXEL_G1_DB_TO_RGBA8888(p1, p2) \
1249 GP_PIXEL_G1_DB_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1250
1251/*
1252 * Converts RGBA8888 -> G2_DB
1253 *
1254 * macro reads p1 (RGBA8888 at bit-offset o1)
1255 * and writes to p2 (G2_DB at bit-offset o2)
1256 * the relevant part of p2 is assumed to be cleared (zero)
1257 */
1258#define GP_PIXEL_RGBA8888_TO_G2_DB_OFFSET(p1, o1, p2, o2) do { \
1259 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 2, p2, ( \
1260 /* R */ GP_SCALE_VAL_8_2(GP_GET_BITS(24+o1, 8, p1)) + \
1261 /* G */ GP_SCALE_VAL_8_2(GP_GET_BITS(16+o1, 8, p1)) + \
1262 /* B */ GP_SCALE_VAL_8_2(GP_GET_BITS(8+o1, 8, p1)) + \
1263 0)/3);\
1264} while (0)
1265
1266/* a version without offsets */
1267#define GP_PIXEL_RGBA8888_TO_G2_DB(p1, p2) \
1268 GP_PIXEL_RGBA8888_TO_G2_DB_OFFSET(p1, 0, p2, 0)
1269
1270/*
1271 * Converts G2_DB -> RGBA8888
1272 *
1273 * macro reads p1 (G2_DB at bit-offset o1)
1274 * and writes to p2 (RGBA8888 at bit-offset o2)
1275 * the relevant part of p2 is assumed to be cleared (zero)
1276 */
1277#define GP_PIXEL_G2_DB_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1278 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1279 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
1280 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1281 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
1282 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1283 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
1284 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1285} while (0)
1286
1287/* a version without offsets */
1288#define GP_PIXEL_G2_DB_TO_RGBA8888(p1, p2) \
1289 GP_PIXEL_G2_DB_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1290
1291/*
1292 * Converts RGBA8888 -> G4_DB
1293 *
1294 * macro reads p1 (RGBA8888 at bit-offset o1)
1295 * and writes to p2 (G4_DB at bit-offset o2)
1296 * the relevant part of p2 is assumed to be cleared (zero)
1297 */
1298#define GP_PIXEL_RGBA8888_TO_G4_DB_OFFSET(p1, o1, p2, o2) do { \
1299 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 4, p2, ( \
1300 /* R */ GP_SCALE_VAL_8_4(GP_GET_BITS(24+o1, 8, p1)) + \
1301 /* G */ GP_SCALE_VAL_8_4(GP_GET_BITS(16+o1, 8, p1)) + \
1302 /* B */ GP_SCALE_VAL_8_4(GP_GET_BITS(8+o1, 8, p1)) + \
1303 0)/3);\
1304} while (0)
1305
1306/* a version without offsets */
1307#define GP_PIXEL_RGBA8888_TO_G4_DB(p1, p2) \
1308 GP_PIXEL_RGBA8888_TO_G4_DB_OFFSET(p1, 0, p2, 0)
1309
1310/*
1311 * Converts G4_DB -> RGBA8888
1312 *
1313 * macro reads p1 (G4_DB at bit-offset o1)
1314 * and writes to p2 (RGBA8888 at bit-offset o2)
1315 * the relevant part of p2 is assumed to be cleared (zero)
1316 */
1317#define GP_PIXEL_G4_DB_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1318 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1319 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
1320 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1321 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
1322 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1323 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
1324 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1325} while (0)
1326
1327/* a version without offsets */
1328#define GP_PIXEL_G4_DB_TO_RGBA8888(p1, p2) \
1329 GP_PIXEL_G4_DB_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1330
1331/*
1332 * Converts RGBA8888 -> G1_UB
1333 *
1334 * macro reads p1 (RGBA8888 at bit-offset o1)
1335 * and writes to p2 (G1_UB at bit-offset o2)
1336 * the relevant part of p2 is assumed to be cleared (zero)
1337 */
1338#define GP_PIXEL_RGBA8888_TO_G1_UB_OFFSET(p1, o1, p2, o2) do { \
1339 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 1, p2, ( \
1340 /* R */ GP_SCALE_VAL_8_1(GP_GET_BITS(24+o1, 8, p1)) + \
1341 /* G */ GP_SCALE_VAL_8_1(GP_GET_BITS(16+o1, 8, p1)) + \
1342 /* B */ GP_SCALE_VAL_8_1(GP_GET_BITS(8+o1, 8, p1)) + \
1343 0)/3);\
1344} while (0)
1345
1346/* a version without offsets */
1347#define GP_PIXEL_RGBA8888_TO_G1_UB(p1, p2) \
1348 GP_PIXEL_RGBA8888_TO_G1_UB_OFFSET(p1, 0, p2, 0)
1349
1350/*
1351 * Converts G1_UB -> RGBA8888
1352 *
1353 * macro reads p1 (G1_UB at bit-offset o1)
1354 * and writes to p2 (RGBA8888 at bit-offset o2)
1355 * the relevant part of p2 is assumed to be cleared (zero)
1356 */
1357#define GP_PIXEL_G1_UB_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1358 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1359 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
1360 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1361 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
1362 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1363 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
1364 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1365} while (0)
1366
1367/* a version without offsets */
1368#define GP_PIXEL_G1_UB_TO_RGBA8888(p1, p2) \
1369 GP_PIXEL_G1_UB_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1370
1371/*
1372 * Converts RGBA8888 -> G2_UB
1373 *
1374 * macro reads p1 (RGBA8888 at bit-offset o1)
1375 * and writes to p2 (G2_UB at bit-offset o2)
1376 * the relevant part of p2 is assumed to be cleared (zero)
1377 */
1378#define GP_PIXEL_RGBA8888_TO_G2_UB_OFFSET(p1, o1, p2, o2) do { \
1379 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 2, p2, ( \
1380 /* R */ GP_SCALE_VAL_8_2(GP_GET_BITS(24+o1, 8, p1)) + \
1381 /* G */ GP_SCALE_VAL_8_2(GP_GET_BITS(16+o1, 8, p1)) + \
1382 /* B */ GP_SCALE_VAL_8_2(GP_GET_BITS(8+o1, 8, p1)) + \
1383 0)/3);\
1384} while (0)
1385
1386/* a version without offsets */
1387#define GP_PIXEL_RGBA8888_TO_G2_UB(p1, p2) \
1388 GP_PIXEL_RGBA8888_TO_G2_UB_OFFSET(p1, 0, p2, 0)
1389
1390/*
1391 * Converts G2_UB -> RGBA8888
1392 *
1393 * macro reads p1 (G2_UB at bit-offset o1)
1394 * and writes to p2 (RGBA8888 at bit-offset o2)
1395 * the relevant part of p2 is assumed to be cleared (zero)
1396 */
1397#define GP_PIXEL_G2_UB_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1398 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1399 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
1400 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1401 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
1402 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1403 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
1404 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1405} while (0)
1406
1407/* a version without offsets */
1408#define GP_PIXEL_G2_UB_TO_RGBA8888(p1, p2) \
1409 GP_PIXEL_G2_UB_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1410
1411/*
1412 * Converts RGBA8888 -> G4_UB
1413 *
1414 * macro reads p1 (RGBA8888 at bit-offset o1)
1415 * and writes to p2 (G4_UB at bit-offset o2)
1416 * the relevant part of p2 is assumed to be cleared (zero)
1417 */
1418#define GP_PIXEL_RGBA8888_TO_G4_UB_OFFSET(p1, o1, p2, o2) do { \
1419 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 4, p2, ( \
1420 /* R */ GP_SCALE_VAL_8_4(GP_GET_BITS(24+o1, 8, p1)) + \
1421 /* G */ GP_SCALE_VAL_8_4(GP_GET_BITS(16+o1, 8, p1)) + \
1422 /* B */ GP_SCALE_VAL_8_4(GP_GET_BITS(8+o1, 8, p1)) + \
1423 0)/3);\
1424} while (0)
1425
1426/* a version without offsets */
1427#define GP_PIXEL_RGBA8888_TO_G4_UB(p1, p2) \
1428 GP_PIXEL_RGBA8888_TO_G4_UB_OFFSET(p1, 0, p2, 0)
1429
1430/*
1431 * Converts G4_UB -> RGBA8888
1432 *
1433 * macro reads p1 (G4_UB at bit-offset o1)
1434 * and writes to p2 (RGBA8888 at bit-offset o2)
1435 * the relevant part of p2 is assumed to be cleared (zero)
1436 */
1437#define GP_PIXEL_G4_UB_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1438 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1439 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
1440 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1441 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
1442 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1443 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
1444 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1445} while (0)
1446
1447/* a version without offsets */
1448#define GP_PIXEL_G4_UB_TO_RGBA8888(p1, p2) \
1449 GP_PIXEL_G4_UB_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1450
1451/*
1452 * Converts RGBA8888 -> G8
1453 *
1454 * macro reads p1 (RGBA8888 at bit-offset o1)
1455 * and writes to p2 (G8 at bit-offset o2)
1456 * the relevant part of p2 is assumed to be cleared (zero)
1457 */
1458#define GP_PIXEL_RGBA8888_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1459 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1460 /* R */ GP_SCALE_VAL_8_8(GP_GET_BITS(24+o1, 8, p1)) + \
1461 /* G */ GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)) + \
1462 /* B */ GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)) + \
1463 0)/3);\
1464} while (0)
1465
1466/* a version without offsets */
1467#define GP_PIXEL_RGBA8888_TO_G8(p1, p2) \
1468 GP_PIXEL_RGBA8888_TO_G8_OFFSET(p1, 0, p2, 0)
1469
1470/*
1471 * Converts RGBA8888 -> GA88
1472 *
1473 * macro reads p1 (RGBA8888 at bit-offset o1)
1474 * and writes to p2 (GA88 at bit-offset o2)
1475 * the relevant part of p2 is assumed to be cleared (zero)
1476 */
1477#define GP_PIXEL_RGBA8888_TO_GA88_OFFSET(p1, o1, p2, o2) do { \
1478 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1479 /* R */ GP_SCALE_VAL_8_8(GP_GET_BITS(24+o1, 8, p1)) + \
1480 /* G */ GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)) + \
1481 /* B */ GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)) + \
1482 0)/3);\
1483 /* A:=A */ GP_SET_BITS(8+o2, 8, p2,\
1484 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1485} while (0)
1486
1487/* a version without offsets */
1488#define GP_PIXEL_RGBA8888_TO_GA88(p1, p2) \
1489 GP_PIXEL_RGBA8888_TO_GA88_OFFSET(p1, 0, p2, 0)
1490
1491/*
1492 * Converts GA88 -> RGBA8888
1493 *
1494 * macro reads p1 (GA88 at bit-offset o1)
1495 * and writes to p2 (RGBA8888 at bit-offset o2)
1496 * the relevant part of p2 is assumed to be cleared (zero)
1497 */
1498#define GP_PIXEL_GA88_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1499 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1500 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1501 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1502 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1503 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1504 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1505 /* A:=A */ GP_SET_BITS(0+o2, 8, p2,\
1506 GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1))); \
1507} while (0)
1508
1509/* a version without offsets */
1510#define GP_PIXEL_GA88_TO_RGBA8888(p1, p2) \
1511 GP_PIXEL_GA88_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1512
1513/*
1514 * Converts RGBA8888 -> G16
1515 *
1516 * macro reads p1 (RGBA8888 at bit-offset o1)
1517 * and writes to p2 (G16 at bit-offset o2)
1518 * the relevant part of p2 is assumed to be cleared (zero)
1519 */
1520#define GP_PIXEL_RGBA8888_TO_G16_OFFSET(p1, o1, p2, o2) do { \
1521 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 16, p2, ( \
1522 /* R */ GP_SCALE_VAL_8_16(GP_GET_BITS(24+o1, 8, p1)) + \
1523 /* G */ GP_SCALE_VAL_8_16(GP_GET_BITS(16+o1, 8, p1)) + \
1524 /* B */ GP_SCALE_VAL_8_16(GP_GET_BITS(8+o1, 8, p1)) + \
1525 0)/3);\
1526} while (0)
1527
1528/* a version without offsets */
1529#define GP_PIXEL_RGBA8888_TO_G16(p1, p2) \
1530 GP_PIXEL_RGBA8888_TO_G16_OFFSET(p1, 0, p2, 0)
1531
1532/*
1533 * Converts G16 -> RGBA8888
1534 *
1535 * macro reads p1 (G16 at bit-offset o1)
1536 * and writes to p2 (RGBA8888 at bit-offset o2)
1537 * the relevant part of p2 is assumed to be cleared (zero)
1538 */
1539#define GP_PIXEL_G16_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1540 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1541 GP_SCALE_VAL_16_8(GP_GET_BITS(0+o1, 16, p1))); \
1542 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1543 GP_SCALE_VAL_16_8(GP_GET_BITS(0+o1, 16, p1))); \
1544 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1545 GP_SCALE_VAL_16_8(GP_GET_BITS(0+o1, 16, p1))); \
1546 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1547} while (0)
1548
1549/* a version without offsets */
1550#define GP_PIXEL_G16_TO_RGBA8888(p1, p2) \
1551 GP_PIXEL_G16_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1552
1553
1564gp_pixel gp_RGBA8888_to_pixel(gp_pixel pixel, gp_pixel_type type);
1565
1576gp_pixel gp_pixel_to_RGBA8888(gp_pixel pixel, gp_pixel_type type);
1577
1578/*
1579 * Converts G8 -> RGB101010
1580 *
1581 * macro reads p1 (G8 at bit-offset o1)
1582 * and writes to p2 (RGB101010 at bit-offset o2)
1583 * the relevant part of p2 is assumed to be cleared (zero)
1584 */
1585#define GP_PIXEL_G8_TO_RGB101010_OFFSET(p1, o1, p2, o2) do { \
1586 /* R:=V */ GP_SET_BITS(20+o2, 10, p2,\
1587 GP_SCALE_VAL_8_10(GP_GET_BITS(0+o1, 8, p1))); \
1588 /* G:=V */ GP_SET_BITS(10+o2, 10, p2,\
1589 GP_SCALE_VAL_8_10(GP_GET_BITS(0+o1, 8, p1))); \
1590 /* B:=V */ GP_SET_BITS(0+o2, 10, p2,\
1591 GP_SCALE_VAL_8_10(GP_GET_BITS(0+o1, 8, p1))); \
1592} while (0)
1593
1594/* a version without offsets */
1595#define GP_PIXEL_G8_TO_RGB101010(p1, p2) \
1596 GP_PIXEL_G8_TO_RGB101010_OFFSET(p1, 0, p2, 0)
1597
1598/*
1599 * Converts RGB101010 -> G8
1600 *
1601 * macro reads p1 (RGB101010 at bit-offset o1)
1602 * and writes to p2 (G8 at bit-offset o2)
1603 * the relevant part of p2 is assumed to be cleared (zero)
1604 */
1605#define GP_PIXEL_RGB101010_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1606 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1607 /* R */ GP_SCALE_VAL_10_8(GP_GET_BITS(20+o1, 10, p1)) + \
1608 /* G */ GP_SCALE_VAL_10_8(GP_GET_BITS(10+o1, 10, p1)) + \
1609 /* B */ GP_SCALE_VAL_10_8(GP_GET_BITS(0+o1, 10, p1)) + \
1610 0)/3);\
1611} while (0)
1612
1613/* a version without offsets */
1614#define GP_PIXEL_RGB101010_TO_G8(p1, p2) \
1615 GP_PIXEL_RGB101010_TO_G8_OFFSET(p1, 0, p2, 0)
1616
1617/*
1618 * Converts G8 -> xRGB8888
1619 *
1620 * macro reads p1 (G8 at bit-offset o1)
1621 * and writes to p2 (xRGB8888 at bit-offset o2)
1622 * the relevant part of p2 is assumed to be cleared (zero)
1623 */
1624#define GP_PIXEL_G8_TO_xRGB8888_OFFSET(p1, o1, p2, o2) do { \
1625 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
1626 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1627 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
1628 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1629 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
1630 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1631} while (0)
1632
1633/* a version without offsets */
1634#define GP_PIXEL_G8_TO_xRGB8888(p1, p2) \
1635 GP_PIXEL_G8_TO_xRGB8888_OFFSET(p1, 0, p2, 0)
1636
1637/*
1638 * Converts xRGB8888 -> G8
1639 *
1640 * macro reads p1 (xRGB8888 at bit-offset o1)
1641 * and writes to p2 (G8 at bit-offset o2)
1642 * the relevant part of p2 is assumed to be cleared (zero)
1643 */
1644#define GP_PIXEL_xRGB8888_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1645 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1646 /* R */ GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)) + \
1647 /* G */ GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)) + \
1648 /* B */ GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1)) + \
1649 0)/3);\
1650} while (0)
1651
1652/* a version without offsets */
1653#define GP_PIXEL_xRGB8888_TO_G8(p1, p2) \
1654 GP_PIXEL_xRGB8888_TO_G8_OFFSET(p1, 0, p2, 0)
1655
1656/*
1657 * Converts G8 -> RGBA8888
1658 *
1659 * macro reads p1 (G8 at bit-offset o1)
1660 * and writes to p2 (RGBA8888 at bit-offset o2)
1661 * the relevant part of p2 is assumed to be cleared (zero)
1662 */
1663#define GP_PIXEL_G8_TO_RGBA8888_OFFSET(p1, o1, p2, o2) do { \
1664 /* R:=V */ GP_SET_BITS(24+o2, 8, p2,\
1665 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1666 /* G:=V */ GP_SET_BITS(16+o2, 8, p2,\
1667 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1668 /* B:=V */ GP_SET_BITS(8+o2, 8, p2,\
1669 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1670 /* A:=0xff */GP_SET_BITS(0+o2, 8, p2, 0xff); \
1671} while (0)
1672
1673/* a version without offsets */
1674#define GP_PIXEL_G8_TO_RGBA8888(p1, p2) \
1675 GP_PIXEL_G8_TO_RGBA8888_OFFSET(p1, 0, p2, 0)
1676
1677/*
1678 * Converts G8 -> RGB888
1679 *
1680 * macro reads p1 (G8 at bit-offset o1)
1681 * and writes to p2 (RGB888 at bit-offset o2)
1682 * the relevant part of p2 is assumed to be cleared (zero)
1683 */
1684#define GP_PIXEL_G8_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
1685 /* R:=V */ GP_SET_BITS(16+o2, 8, p2,\
1686 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1687 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
1688 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1689 /* B:=V */ GP_SET_BITS(0+o2, 8, p2,\
1690 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1691} while (0)
1692
1693/* a version without offsets */
1694#define GP_PIXEL_G8_TO_RGB888(p1, p2) \
1695 GP_PIXEL_G8_TO_RGB888_OFFSET(p1, 0, p2, 0)
1696
1697/*
1698 * Converts G8 -> BGR888
1699 *
1700 * macro reads p1 (G8 at bit-offset o1)
1701 * and writes to p2 (BGR888 at bit-offset o2)
1702 * the relevant part of p2 is assumed to be cleared (zero)
1703 */
1704#define GP_PIXEL_G8_TO_BGR888_OFFSET(p1, o1, p2, o2) do { \
1705 /* B:=V */ GP_SET_BITS(16+o2, 8, p2,\
1706 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1707 /* G:=V */ GP_SET_BITS(8+o2, 8, p2,\
1708 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1709 /* R:=V */ GP_SET_BITS(0+o2, 8, p2,\
1710 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
1711} while (0)
1712
1713/* a version without offsets */
1714#define GP_PIXEL_G8_TO_BGR888(p1, p2) \
1715 GP_PIXEL_G8_TO_BGR888_OFFSET(p1, 0, p2, 0)
1716
1717/*
1718 * Converts BGR888 -> G8
1719 *
1720 * macro reads p1 (BGR888 at bit-offset o1)
1721 * and writes to p2 (G8 at bit-offset o2)
1722 * the relevant part of p2 is assumed to be cleared (zero)
1723 */
1724#define GP_PIXEL_BGR888_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1725 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1726 /* R */ GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1)) + \
1727 /* G */ GP_SCALE_VAL_8_8(GP_GET_BITS(8+o1, 8, p1)) + \
1728 /* B */ GP_SCALE_VAL_8_8(GP_GET_BITS(16+o1, 8, p1)) + \
1729 0)/3);\
1730} while (0)
1731
1732/* a version without offsets */
1733#define GP_PIXEL_BGR888_TO_G8(p1, p2) \
1734 GP_PIXEL_BGR888_TO_G8_OFFSET(p1, 0, p2, 0)
1735
1736/*
1737 * Converts G8 -> RGB555
1738 *
1739 * macro reads p1 (G8 at bit-offset o1)
1740 * and writes to p2 (RGB555 at bit-offset o2)
1741 * the relevant part of p2 is assumed to be cleared (zero)
1742 */
1743#define GP_PIXEL_G8_TO_RGB555_OFFSET(p1, o1, p2, o2) do { \
1744 /* R:=V */ GP_SET_BITS(10+o2, 5, p2,\
1745 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
1746 /* G:=V */ GP_SET_BITS(5+o2, 5, p2,\
1747 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
1748 /* B:=V */ GP_SET_BITS(0+o2, 5, p2,\
1749 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
1750} while (0)
1751
1752/* a version without offsets */
1753#define GP_PIXEL_G8_TO_RGB555(p1, p2) \
1754 GP_PIXEL_G8_TO_RGB555_OFFSET(p1, 0, p2, 0)
1755
1756/*
1757 * Converts RGB555 -> G8
1758 *
1759 * macro reads p1 (RGB555 at bit-offset o1)
1760 * and writes to p2 (G8 at bit-offset o2)
1761 * the relevant part of p2 is assumed to be cleared (zero)
1762 */
1763#define GP_PIXEL_RGB555_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1764 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1765 /* R */ GP_SCALE_VAL_5_8(GP_GET_BITS(10+o1, 5, p1)) + \
1766 /* G */ GP_SCALE_VAL_5_8(GP_GET_BITS(5+o1, 5, p1)) + \
1767 /* B */ GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1)) + \
1768 0)/3);\
1769} while (0)
1770
1771/* a version without offsets */
1772#define GP_PIXEL_RGB555_TO_G8(p1, p2) \
1773 GP_PIXEL_RGB555_TO_G8_OFFSET(p1, 0, p2, 0)
1774
1775/*
1776 * Converts G8 -> RGB565_BE
1777 *
1778 * macro reads p1 (G8 at bit-offset o1)
1779 * and writes to p2 (RGB565_BE at bit-offset o2)
1780 * the relevant part of p2 is assumed to be cleared (zero)
1781 */
1782#define GP_PIXEL_G8_TO_RGB565_BE_OFFSET(p1, o1, p2, o2) do { \
1783 /* R:=V */ GP_SET_BITS(11+o2, 5, p2,\
1784 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
1785 /* G:=V */ GP_SET_BITS(5+o2, 6, p2,\
1786 GP_SCALE_VAL_8_6(GP_GET_BITS(0+o1, 8, p1))); \
1787 /* B:=V */ GP_SET_BITS(0+o2, 5, p2,\
1788 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
1789} while (0)
1790
1791/* a version without offsets */
1792#define GP_PIXEL_G8_TO_RGB565_BE(p1, p2) \
1793 GP_PIXEL_G8_TO_RGB565_BE_OFFSET(p1, 0, p2, 0)
1794
1795/*
1796 * Converts RGB565_BE -> G8
1797 *
1798 * macro reads p1 (RGB565_BE at bit-offset o1)
1799 * and writes to p2 (G8 at bit-offset o2)
1800 * the relevant part of p2 is assumed to be cleared (zero)
1801 */
1802#define GP_PIXEL_RGB565_BE_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1803 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1804 /* R */ GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1)) + \
1805 /* G */ GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1)) + \
1806 /* B */ GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1)) + \
1807 0)/3);\
1808} while (0)
1809
1810/* a version without offsets */
1811#define GP_PIXEL_RGB565_BE_TO_G8(p1, p2) \
1812 GP_PIXEL_RGB565_BE_TO_G8_OFFSET(p1, 0, p2, 0)
1813
1814/*
1815 * Converts G8 -> RGB565_LE
1816 *
1817 * macro reads p1 (G8 at bit-offset o1)
1818 * and writes to p2 (RGB565_LE at bit-offset o2)
1819 * the relevant part of p2 is assumed to be cleared (zero)
1820 */
1821#define GP_PIXEL_G8_TO_RGB565_LE_OFFSET(p1, o1, p2, o2) do { \
1822 /* R:=V */ GP_SET_BITS(11+o2, 5, p2,\
1823 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
1824 /* G:=V */ GP_SET_BITS(5+o2, 6, p2,\
1825 GP_SCALE_VAL_8_6(GP_GET_BITS(0+o1, 8, p1))); \
1826 /* B:=V */ GP_SET_BITS(0+o2, 5, p2,\
1827 GP_SCALE_VAL_8_5(GP_GET_BITS(0+o1, 8, p1))); \
1828} while (0)
1829
1830/* a version without offsets */
1831#define GP_PIXEL_G8_TO_RGB565_LE(p1, p2) \
1832 GP_PIXEL_G8_TO_RGB565_LE_OFFSET(p1, 0, p2, 0)
1833
1834/*
1835 * Converts RGB565_LE -> G8
1836 *
1837 * macro reads p1 (RGB565_LE at bit-offset o1)
1838 * and writes to p2 (G8 at bit-offset o2)
1839 * the relevant part of p2 is assumed to be cleared (zero)
1840 */
1841#define GP_PIXEL_RGB565_LE_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1842 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1843 /* R */ GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1)) + \
1844 /* G */ GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1)) + \
1845 /* B */ GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1)) + \
1846 0)/3);\
1847} while (0)
1848
1849/* a version without offsets */
1850#define GP_PIXEL_RGB565_LE_TO_G8(p1, p2) \
1851 GP_PIXEL_RGB565_LE_TO_G8_OFFSET(p1, 0, p2, 0)
1852
1853/*
1854 * Converts G8 -> RGB666
1855 *
1856 * macro reads p1 (G8 at bit-offset o1)
1857 * and writes to p2 (RGB666 at bit-offset o2)
1858 * the relevant part of p2 is assumed to be cleared (zero)
1859 */
1860#define GP_PIXEL_G8_TO_RGB666_OFFSET(p1, o1, p2, o2) do { \
1861 /* R:=V */ GP_SET_BITS(12+o2, 6, p2,\
1862 GP_SCALE_VAL_8_6(GP_GET_BITS(0+o1, 8, p1))); \
1863 /* G:=V */ GP_SET_BITS(6+o2, 6, p2,\
1864 GP_SCALE_VAL_8_6(GP_GET_BITS(0+o1, 8, p1))); \
1865 /* B:=V */ GP_SET_BITS(0+o2, 6, p2,\
1866 GP_SCALE_VAL_8_6(GP_GET_BITS(0+o1, 8, p1))); \
1867} while (0)
1868
1869/* a version without offsets */
1870#define GP_PIXEL_G8_TO_RGB666(p1, p2) \
1871 GP_PIXEL_G8_TO_RGB666_OFFSET(p1, 0, p2, 0)
1872
1873/*
1874 * Converts RGB666 -> G8
1875 *
1876 * macro reads p1 (RGB666 at bit-offset o1)
1877 * and writes to p2 (G8 at bit-offset o2)
1878 * the relevant part of p2 is assumed to be cleared (zero)
1879 */
1880#define GP_PIXEL_RGB666_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1881 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1882 /* R */ GP_SCALE_VAL_6_8(GP_GET_BITS(12+o1, 6, p1)) + \
1883 /* G */ GP_SCALE_VAL_6_8(GP_GET_BITS(6+o1, 6, p1)) + \
1884 /* B */ GP_SCALE_VAL_6_8(GP_GET_BITS(0+o1, 6, p1)) + \
1885 0)/3);\
1886} while (0)
1887
1888/* a version without offsets */
1889#define GP_PIXEL_RGB666_TO_G8(p1, p2) \
1890 GP_PIXEL_RGB666_TO_G8_OFFSET(p1, 0, p2, 0)
1891
1892/*
1893 * Converts G8 -> RGB332
1894 *
1895 * macro reads p1 (G8 at bit-offset o1)
1896 * and writes to p2 (RGB332 at bit-offset o2)
1897 * the relevant part of p2 is assumed to be cleared (zero)
1898 */
1899#define GP_PIXEL_G8_TO_RGB332_OFFSET(p1, o1, p2, o2) do { \
1900 /* R:=V */ GP_SET_BITS(5+o2, 3, p2,\
1901 GP_SCALE_VAL_8_3(GP_GET_BITS(0+o1, 8, p1))); \
1902 /* G:=V */ GP_SET_BITS(2+o2, 3, p2,\
1903 GP_SCALE_VAL_8_3(GP_GET_BITS(0+o1, 8, p1))); \
1904 /* B:=V */ GP_SET_BITS(0+o2, 2, p2,\
1905 GP_SCALE_VAL_8_2(GP_GET_BITS(0+o1, 8, p1))); \
1906} while (0)
1907
1908/* a version without offsets */
1909#define GP_PIXEL_G8_TO_RGB332(p1, p2) \
1910 GP_PIXEL_G8_TO_RGB332_OFFSET(p1, 0, p2, 0)
1911
1912/*
1913 * Converts RGB332 -> G8
1914 *
1915 * macro reads p1 (RGB332 at bit-offset o1)
1916 * and writes to p2 (G8 at bit-offset o2)
1917 * the relevant part of p2 is assumed to be cleared (zero)
1918 */
1919#define GP_PIXEL_RGB332_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1920 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 8, p2, ( \
1921 /* R */ GP_SCALE_VAL_3_8(GP_GET_BITS(5+o1, 3, p1)) + \
1922 /* G */ GP_SCALE_VAL_3_8(GP_GET_BITS(2+o1, 3, p1)) + \
1923 /* B */ GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1)) + \
1924 0)/3);\
1925} while (0)
1926
1927/* a version without offsets */
1928#define GP_PIXEL_RGB332_TO_G8(p1, p2) \
1929 GP_PIXEL_RGB332_TO_G8_OFFSET(p1, 0, p2, 0)
1930
1931/*
1932 * Converts G8 -> CMYK8888
1933 *
1934 * macro reads p1 (G8 at bit-offset o1)
1935 * and writes to p2 (CMYK8888 at bit-offset o2)
1936 * the relevant part of p2 is assumed to be cleared (zero)
1937 */
1938#define GP_PIXEL_G8_TO_CMYK8888_OFFSET(p1, o1, p2, o2) do { \
1939GP_ABORT("Channel conversion G8 to CMYK8888 not supported."); \
1940GP_ABORT("Channel conversion G8 to CMYK8888 not supported."); \
1941GP_ABORT("Channel conversion G8 to CMYK8888 not supported."); \
1942GP_ABORT("Channel conversion G8 to CMYK8888 not supported."); \
1943} while (0)
1944
1945/* a version without offsets */
1946#define GP_PIXEL_G8_TO_CMYK8888(p1, p2) \
1947 GP_PIXEL_G8_TO_CMYK8888_OFFSET(p1, 0, p2, 0)
1948
1949/*
1950 * Converts CMYK8888 -> G8
1951 *
1952 * macro reads p1 (CMYK8888 at bit-offset o1)
1953 * and writes to p2 (G8 at bit-offset o2)
1954 * the relevant part of p2 is assumed to be cleared (zero)
1955 */
1956#define GP_PIXEL_CMYK8888_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1957 GP_SET_BITS(0+o2, 8, p2, (\
1958 ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
1959 (0xff - GP_GET_BITS(0+o1, 8, p1)))) / (0xff * 0xff) \
1960 + ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
1961 + (0xff - GP_GET_BITS(8+o1, 8, p1)))) / (0xff * 0xff) \
1962 + ((0xff * (0xff - GP_GET_BITS(24+o1, 8, p1)) * \
1963 + (0xff - GP_GET_BITS(16+o1, 8, p1)))) / (0xff * 0xff) \
1964 )/3); \
1965} while (0)
1966
1967/* a version without offsets */
1968#define GP_PIXEL_CMYK8888_TO_G8(p1, p2) \
1969 GP_PIXEL_CMYK8888_TO_G8_OFFSET(p1, 0, p2, 0)
1970
1971/*
1972 * Converts G8 -> G1_DB
1973 *
1974 * macro reads p1 (G8 at bit-offset o1)
1975 * and writes to p2 (G1_DB at bit-offset o2)
1976 * the relevant part of p2 is assumed to be cleared (zero)
1977 */
1978#define GP_PIXEL_G8_TO_G1_DB_OFFSET(p1, o1, p2, o2) do { \
1979 /* V:=V */ GP_SET_BITS(0+o2, 1, p2,\
1980 GP_SCALE_VAL_8_1(GP_GET_BITS(0+o1, 8, p1))); \
1981} while (0)
1982
1983/* a version without offsets */
1984#define GP_PIXEL_G8_TO_G1_DB(p1, p2) \
1985 GP_PIXEL_G8_TO_G1_DB_OFFSET(p1, 0, p2, 0)
1986
1987/*
1988 * Converts G1_DB -> G8
1989 *
1990 * macro reads p1 (G1_DB at bit-offset o1)
1991 * and writes to p2 (G8 at bit-offset o2)
1992 * the relevant part of p2 is assumed to be cleared (zero)
1993 */
1994#define GP_PIXEL_G1_DB_TO_G8_OFFSET(p1, o1, p2, o2) do { \
1995 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
1996 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
1997} while (0)
1998
1999/* a version without offsets */
2000#define GP_PIXEL_G1_DB_TO_G8(p1, p2) \
2001 GP_PIXEL_G1_DB_TO_G8_OFFSET(p1, 0, p2, 0)
2002
2003/*
2004 * Converts G8 -> G2_DB
2005 *
2006 * macro reads p1 (G8 at bit-offset o1)
2007 * and writes to p2 (G2_DB at bit-offset o2)
2008 * the relevant part of p2 is assumed to be cleared (zero)
2009 */
2010#define GP_PIXEL_G8_TO_G2_DB_OFFSET(p1, o1, p2, o2) do { \
2011 /* V:=V */ GP_SET_BITS(0+o2, 2, p2,\
2012 GP_SCALE_VAL_8_2(GP_GET_BITS(0+o1, 8, p1))); \
2013} while (0)
2014
2015/* a version without offsets */
2016#define GP_PIXEL_G8_TO_G2_DB(p1, p2) \
2017 GP_PIXEL_G8_TO_G2_DB_OFFSET(p1, 0, p2, 0)
2018
2019/*
2020 * Converts G2_DB -> G8
2021 *
2022 * macro reads p1 (G2_DB at bit-offset o1)
2023 * and writes to p2 (G8 at bit-offset o2)
2024 * the relevant part of p2 is assumed to be cleared (zero)
2025 */
2026#define GP_PIXEL_G2_DB_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2027 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2028 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
2029} while (0)
2030
2031/* a version without offsets */
2032#define GP_PIXEL_G2_DB_TO_G8(p1, p2) \
2033 GP_PIXEL_G2_DB_TO_G8_OFFSET(p1, 0, p2, 0)
2034
2035/*
2036 * Converts G8 -> G4_DB
2037 *
2038 * macro reads p1 (G8 at bit-offset o1)
2039 * and writes to p2 (G4_DB at bit-offset o2)
2040 * the relevant part of p2 is assumed to be cleared (zero)
2041 */
2042#define GP_PIXEL_G8_TO_G4_DB_OFFSET(p1, o1, p2, o2) do { \
2043 /* V:=V */ GP_SET_BITS(0+o2, 4, p2,\
2044 GP_SCALE_VAL_8_4(GP_GET_BITS(0+o1, 8, p1))); \
2045} while (0)
2046
2047/* a version without offsets */
2048#define GP_PIXEL_G8_TO_G4_DB(p1, p2) \
2049 GP_PIXEL_G8_TO_G4_DB_OFFSET(p1, 0, p2, 0)
2050
2051/*
2052 * Converts G4_DB -> G8
2053 *
2054 * macro reads p1 (G4_DB at bit-offset o1)
2055 * and writes to p2 (G8 at bit-offset o2)
2056 * the relevant part of p2 is assumed to be cleared (zero)
2057 */
2058#define GP_PIXEL_G4_DB_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2059 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2060 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
2061} while (0)
2062
2063/* a version without offsets */
2064#define GP_PIXEL_G4_DB_TO_G8(p1, p2) \
2065 GP_PIXEL_G4_DB_TO_G8_OFFSET(p1, 0, p2, 0)
2066
2067/*
2068 * Converts G8 -> G1_UB
2069 *
2070 * macro reads p1 (G8 at bit-offset o1)
2071 * and writes to p2 (G1_UB at bit-offset o2)
2072 * the relevant part of p2 is assumed to be cleared (zero)
2073 */
2074#define GP_PIXEL_G8_TO_G1_UB_OFFSET(p1, o1, p2, o2) do { \
2075 /* V:=V */ GP_SET_BITS(0+o2, 1, p2,\
2076 GP_SCALE_VAL_8_1(GP_GET_BITS(0+o1, 8, p1))); \
2077} while (0)
2078
2079/* a version without offsets */
2080#define GP_PIXEL_G8_TO_G1_UB(p1, p2) \
2081 GP_PIXEL_G8_TO_G1_UB_OFFSET(p1, 0, p2, 0)
2082
2083/*
2084 * Converts G1_UB -> G8
2085 *
2086 * macro reads p1 (G1_UB at bit-offset o1)
2087 * and writes to p2 (G8 at bit-offset o2)
2088 * the relevant part of p2 is assumed to be cleared (zero)
2089 */
2090#define GP_PIXEL_G1_UB_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2091 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2092 GP_SCALE_VAL_1_8(GP_GET_BITS(0+o1, 1, p1))); \
2093} while (0)
2094
2095/* a version without offsets */
2096#define GP_PIXEL_G1_UB_TO_G8(p1, p2) \
2097 GP_PIXEL_G1_UB_TO_G8_OFFSET(p1, 0, p2, 0)
2098
2099/*
2100 * Converts G8 -> G2_UB
2101 *
2102 * macro reads p1 (G8 at bit-offset o1)
2103 * and writes to p2 (G2_UB at bit-offset o2)
2104 * the relevant part of p2 is assumed to be cleared (zero)
2105 */
2106#define GP_PIXEL_G8_TO_G2_UB_OFFSET(p1, o1, p2, o2) do { \
2107 /* V:=V */ GP_SET_BITS(0+o2, 2, p2,\
2108 GP_SCALE_VAL_8_2(GP_GET_BITS(0+o1, 8, p1))); \
2109} while (0)
2110
2111/* a version without offsets */
2112#define GP_PIXEL_G8_TO_G2_UB(p1, p2) \
2113 GP_PIXEL_G8_TO_G2_UB_OFFSET(p1, 0, p2, 0)
2114
2115/*
2116 * Converts G2_UB -> G8
2117 *
2118 * macro reads p1 (G2_UB at bit-offset o1)
2119 * and writes to p2 (G8 at bit-offset o2)
2120 * the relevant part of p2 is assumed to be cleared (zero)
2121 */
2122#define GP_PIXEL_G2_UB_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2123 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2124 GP_SCALE_VAL_2_8(GP_GET_BITS(0+o1, 2, p1))); \
2125} while (0)
2126
2127/* a version without offsets */
2128#define GP_PIXEL_G2_UB_TO_G8(p1, p2) \
2129 GP_PIXEL_G2_UB_TO_G8_OFFSET(p1, 0, p2, 0)
2130
2131/*
2132 * Converts G8 -> G4_UB
2133 *
2134 * macro reads p1 (G8 at bit-offset o1)
2135 * and writes to p2 (G4_UB at bit-offset o2)
2136 * the relevant part of p2 is assumed to be cleared (zero)
2137 */
2138#define GP_PIXEL_G8_TO_G4_UB_OFFSET(p1, o1, p2, o2) do { \
2139 /* V:=V */ GP_SET_BITS(0+o2, 4, p2,\
2140 GP_SCALE_VAL_8_4(GP_GET_BITS(0+o1, 8, p1))); \
2141} while (0)
2142
2143/* a version without offsets */
2144#define GP_PIXEL_G8_TO_G4_UB(p1, p2) \
2145 GP_PIXEL_G8_TO_G4_UB_OFFSET(p1, 0, p2, 0)
2146
2147/*
2148 * Converts G4_UB -> G8
2149 *
2150 * macro reads p1 (G4_UB at bit-offset o1)
2151 * and writes to p2 (G8 at bit-offset o2)
2152 * the relevant part of p2 is assumed to be cleared (zero)
2153 */
2154#define GP_PIXEL_G4_UB_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2155 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2156 GP_SCALE_VAL_4_8(GP_GET_BITS(0+o1, 4, p1))); \
2157} while (0)
2158
2159/* a version without offsets */
2160#define GP_PIXEL_G4_UB_TO_G8(p1, p2) \
2161 GP_PIXEL_G4_UB_TO_G8_OFFSET(p1, 0, p2, 0)
2162
2163/*
2164 * Converts G8 -> G8
2165 *
2166 * macro reads p1 (G8 at bit-offset o1)
2167 * and writes to p2 (G8 at bit-offset o2)
2168 * the relevant part of p2 is assumed to be cleared (zero)
2169 */
2170#define GP_PIXEL_G8_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2171 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2172 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
2173} while (0)
2174
2175/* a version without offsets */
2176#define GP_PIXEL_G8_TO_G8(p1, p2) \
2177 GP_PIXEL_G8_TO_G8_OFFSET(p1, 0, p2, 0)
2178
2179/*
2180 * Converts G8 -> GA88
2181 *
2182 * macro reads p1 (G8 at bit-offset o1)
2183 * and writes to p2 (GA88 at bit-offset o2)
2184 * the relevant part of p2 is assumed to be cleared (zero)
2185 */
2186#define GP_PIXEL_G8_TO_GA88_OFFSET(p1, o1, p2, o2) do { \
2187 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2188 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
2189 /* A:=0xff */GP_SET_BITS(8+o2, 8, p2, 0xff); \
2190} while (0)
2191
2192/* a version without offsets */
2193#define GP_PIXEL_G8_TO_GA88(p1, p2) \
2194 GP_PIXEL_G8_TO_GA88_OFFSET(p1, 0, p2, 0)
2195
2196/*
2197 * Converts GA88 -> G8
2198 *
2199 * macro reads p1 (GA88 at bit-offset o1)
2200 * and writes to p2 (G8 at bit-offset o2)
2201 * the relevant part of p2 is assumed to be cleared (zero)
2202 */
2203#define GP_PIXEL_GA88_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2204 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2205 GP_SCALE_VAL_8_8(GP_GET_BITS(0+o1, 8, p1))); \
2206} while (0)
2207
2208/* a version without offsets */
2209#define GP_PIXEL_GA88_TO_G8(p1, p2) \
2210 GP_PIXEL_GA88_TO_G8_OFFSET(p1, 0, p2, 0)
2211
2212/*
2213 * Converts G8 -> G16
2214 *
2215 * macro reads p1 (G8 at bit-offset o1)
2216 * and writes to p2 (G16 at bit-offset o2)
2217 * the relevant part of p2 is assumed to be cleared (zero)
2218 */
2219#define GP_PIXEL_G8_TO_G16_OFFSET(p1, o1, p2, o2) do { \
2220 /* V:=V */ GP_SET_BITS(0+o2, 16, p2,\
2221 GP_SCALE_VAL_8_16(GP_GET_BITS(0+o1, 8, p1))); \
2222} while (0)
2223
2224/* a version without offsets */
2225#define GP_PIXEL_G8_TO_G16(p1, p2) \
2226 GP_PIXEL_G8_TO_G16_OFFSET(p1, 0, p2, 0)
2227
2228/*
2229 * Converts G16 -> G8
2230 *
2231 * macro reads p1 (G16 at bit-offset o1)
2232 * and writes to p2 (G8 at bit-offset o2)
2233 * the relevant part of p2 is assumed to be cleared (zero)
2234 */
2235#define GP_PIXEL_G16_TO_G8_OFFSET(p1, o1, p2, o2) do { \
2236 /* V:=V */ GP_SET_BITS(0+o2, 8, p2,\
2237 GP_SCALE_VAL_16_8(GP_GET_BITS(0+o1, 16, p1))); \
2238} while (0)
2239
2240/* a version without offsets */
2241#define GP_PIXEL_G16_TO_G8(p1, p2) \
2242 GP_PIXEL_G16_TO_G8_OFFSET(p1, 0, p2, 0)
2243
2244
2255gp_pixel gp_G8_to_pixel(gp_pixel pixel, gp_pixel_type type);
2256
2267gp_pixel gp_pixel_to_G8(gp_pixel pixel, gp_pixel_type type);
2268
2269
2270/* Experimental macros testing generated scripts */
2271/*
2272 * Converts RGB565_LE -> RGB888
2273 *
2274 * macro reads p1 (RGB565_LE at bit-offset o1)
2275 * and writes to p2 (RGB888 at bit-offset o2)
2276 * the relevant part of p2 is assumed to be cleared (zero)
2277 */
2278#define GP_PIXEL_RGB565_LE_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
2279 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
2280 GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1))); \
2281 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
2282 GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1))); \
2283 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
2284 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
2285} while (0)
2286
2287/* a version without offsets */
2288#define GP_PIXEL_RGB565_LE_TO_RGB888(p1, p2) \
2289 GP_PIXEL_RGB565_LE_TO_RGB888_OFFSET(p1, 0, p2, 0)
2290
2291/*
2292 * Converts RGB565_BE -> RGB888
2293 *
2294 * macro reads p1 (RGB565_BE at bit-offset o1)
2295 * and writes to p2 (RGB888 at bit-offset o2)
2296 * the relevant part of p2 is assumed to be cleared (zero)
2297 */
2298#define GP_PIXEL_RGB565_BE_TO_RGB888_OFFSET(p1, o1, p2, o2) do { \
2299 /* R:=R */ GP_SET_BITS(16+o2, 8, p2,\
2300 GP_SCALE_VAL_5_8(GP_GET_BITS(11+o1, 5, p1))); \
2301 /* G:=G */ GP_SET_BITS(8+o2, 8, p2,\
2302 GP_SCALE_VAL_6_8(GP_GET_BITS(5+o1, 6, p1))); \
2303 /* B:=B */ GP_SET_BITS(0+o2, 8, p2,\
2304 GP_SCALE_VAL_5_8(GP_GET_BITS(0+o1, 5, p1))); \
2305} while (0)
2306
2307/* a version without offsets */
2308#define GP_PIXEL_RGB565_BE_TO_RGB888(p1, p2) \
2309 GP_PIXEL_RGB565_BE_TO_RGB888_OFFSET(p1, 0, p2, 0)
2310
2311/*
2312 * Converts RGBA8888 -> G2_UB
2313 *
2314 * macro reads p1 (RGBA8888 at bit-offset o1)
2315 * and writes to p2 (G2_UB at bit-offset o2)
2316 * the relevant part of p2 is assumed to be cleared (zero)
2317 */
2318#define GP_PIXEL_RGBA8888_TO_G2_UB_OFFSET(p1, o1, p2, o2) do { \
2319 /* V:=RGB_avg */ GP_SET_BITS(0+o2, 2, p2, ( \
2320 /* R */ GP_SCALE_VAL_8_2(GP_GET_BITS(24+o1, 8, p1)) + \
2321 /* G */ GP_SCALE_VAL_8_2(GP_GET_BITS(16+o1, 8, p1)) + \
2322 /* B */ GP_SCALE_VAL_8_2(GP_GET_BITS(8+o1, 8, p1)) + \
2323 0)/3);\
2324} while (0)
2325
2326/* a version without offsets */
2327#define GP_PIXEL_RGBA8888_TO_G2_UB(p1, p2) \
2328 GP_PIXEL_RGBA8888_TO_G2_UB_OFFSET(p1, 0, p2, 0)
2329
2330#endif /* GP_CONVERT_GEN_H */
gp_pixel
uint32_t gp_pixel
Pixel integer value.
Definition gp_types.h:33
gp_pixel_to_G8
gp_pixel gp_pixel_to_G8(gp_pixel pixel, gp_pixel_type type)
Converts to G8 from any other pixel type.
gp_pixel_to_RGBA8888
gp_pixel gp_pixel_to_RGBA8888(gp_pixel pixel, gp_pixel_type type)
Converts to RGBA8888 from any other pixel type.
gp_pixel_to_RGB888
gp_pixel gp_pixel_to_RGB888(gp_pixel pixel, gp_pixel_type type)
Converts to RGB888 from any other pixel type.
gp_G8_to_pixel
gp_pixel gp_G8_to_pixel(gp_pixel pixel, gp_pixel_type type)
Convert G8 to any other pixel type.
gp_RGB888_to_pixel
gp_pixel gp_RGB888_to_pixel(gp_pixel pixel, gp_pixel_type type)
Convert RGB888 to any other pixel type.
gp_RGBA8888_to_pixel
gp_pixel gp_RGBA8888_to_pixel(gp_pixel pixel, gp_pixel_type type)
Convert RGBA8888 to any other pixel type.
gp_get_set_bits.h
Helper macros to get and set bits given offset and length.
gp_pixel_type
gp_pixel_type
List of all pixel types.
Definition gp_pixel.gen.h:62
gp_pixel.h
A pixel description.
gp_pixmap.h
A pixel buffer.