Debian Codegraph @

modules/lsp-runtime-lib/src/main/mm/pixel.cpp

raw
1 /*
2 * Copyright (C) 2026 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2026 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 25 янв. 2026 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/mm/pixel.h>
23 #include <lsp-plug.in/stdlib/string.h>
24
25 namespace lsp
26 {
27 namespace mm
28 {
29 size_t bits_per_pixel(pixel_format_t format) noexcept
30 {
31 switch (format)
32 {
33 case PIXFMT_G1:
34 case PIXFMT_A1:
35 return 1;
36 case PIXFMT_G2:
37 case PIXFMT_A2:
38 return 2;
39 case PIXFMT_G4:
40 case PIXFMT_A4:
41 return 4;
42 case PIXFMT_G8:
43 case PIXFMT_A8:
44 return 8;
45 case PIXFMT_RGB888:
46 case PIXFMT_BGR888:
47 return 24;
48 case PIXFMT_RGBA8888:
49 case PIXFMT_BGRA8888:
50 case PIXFMT_PRGBA8888:
51 case PIXFMT_PBGRA8888:
52 return 32;
53 default: break;
54 }
55 return 0;
56 }
57
58 size_t device_bits_per_pixel(pixel_format_t format) noexcept
59 {
60 switch (format)
61 {
62 case PIXFMT_G1:
63 case PIXFMT_A1:
64 return 1;
65 case PIXFMT_G2:
66 case PIXFMT_A2:
67 return 2;
68 case PIXFMT_G4:
69 case PIXFMT_A4:
70 return 4;
71 case PIXFMT_G8:
72 case PIXFMT_A8:
73 return 8;
74 case PIXFMT_RGB888:
75 case PIXFMT_BGR888:
76 return 24;
77 case PIXFMT_RGBA8888:
78 case PIXFMT_BGRA8888:
79 case PIXFMT_PRGBA8888:
80 case PIXFMT_PBGRA8888:
81 return 32;
82 default: break;
83 }
84 return 0;
85 }
86
87 const char *pixel_format_name(pixel_format_t format) noexcept
88 {
89 switch (format)
90 {
91 case PIXFMT_DEFAULT: return "default";
92 case PIXFMT_G1: return "G1";
93 case PIXFMT_G2: return "G2";
94 case PIXFMT_G4: return "G4";
95 case PIXFMT_G8: return "G8";
96 case PIXFMT_A1: return "A1";
97 case PIXFMT_A2: return "A2";
98 case PIXFMT_A4: return "A4";
99 case PIXFMT_A8: return "A8";
100 case PIXFMT_RGB888: return "RGB888";
101 case PIXFMT_BGR888: return "RGB888";
102 case PIXFMT_RGBA8888: return "RGBA8888";
103 case PIXFMT_BGRA8888: return "BGRA8888";
104 case PIXFMT_PRGBA8888: return "PRGBA8888";
105 case PIXFMT_PBGRA8888: return "PBGRA8888";
106 default: break;
107 }
108 return "unknown";
109 }
110
111 bool is_exact_copy_of_pixel(pixel_format_t dst, pixel_format_t src) noexcept
112 {
113 if (dst == src)
114 return true;
115 switch (dst)
116 {
117 case PIXFMT_G1: return src == PIXFMT_A1;
118 case PIXFMT_G2: return src == PIXFMT_A2;
119 case PIXFMT_G4: return src == PIXFMT_A4;
120 case PIXFMT_G8: return src == PIXFMT_A8;
121 case PIXFMT_A1: return src == PIXFMT_G1;
122 case PIXFMT_A2: return src == PIXFMT_G2;
123 case PIXFMT_A4: return src == PIXFMT_G4;
124 case PIXFMT_A8: return src == PIXFMT_G8;
125 default:
126 break;
127 }
128 return false;
129 }
130
131 static const uint8_t b1tob2_table[] =
132 {
133 0x00, 0x03, 0x0c, 0x0f,
134 0x30, 0x33, 0x3c, 0x3f,
135 0xc0, 0xc3, 0xcc, 0xcf,
136 0xf0, 0xf3, 0xfc, 0xff,
137 };
138
139 static void convert_b1_to_b2(uint8_t *dst, const uint8_t *src, size_t count)
140 {
141 uint8_t v;
142 for ( ; count >= 8; count -= 8)
143 {
144 v = *(src++);
145 dst[0] = b1tob2_table[v & 0x0f];
146 dst[1] = b1tob2_table[v >> 4];
147 dst += 2;
148 }
149 if (count <= 0)
150 return;
151
152 v = *src;
153 if (count >= 4)
154 {
155 *dst++ = b1tob2_table[v & 0x0f];
156 v >>= 4;
157 count -= 4;
158 }
159 if (count > 0)
160 *dst = b1tob2_table[v & 0x0f] & uint8_t((1 << (count*2)) - 1);
161 }
162
163 static const uint8_t b1tob4_table[] =
164 {
165 0x00, 0x0f, 0xf0, 0xff
166 };
167
168 static void convert_b1_to_b4(uint8_t *dst, const uint8_t *src, size_t count)
169 {
170 uint8_t v;
171 for ( ; count >= 8; count -= 8)
172 {
173 v = *(src++);
174 dst[0] = b1tob4_table[v & 0x03];
175 dst[1] = b1tob4_table[(v >> 2) & 0x03];
176 dst[2] = b1tob4_table[(v >> 4) & 0x03];
177 dst[3] = b1tob4_table[(v >> 6) & 0x03];
178 dst += 4;
179 }
180 if (count <= 0)
181 return;
182
183 v = *src;
184 if (count >= 4)
185 {
186 dst[0] = b1tob4_table[v & 0x03];
187 dst[1] = b1tob4_table[(v >> 2) & 0x03];
188 v >>= 4;
189 dst += 2;
190 count -= 4;
191 }
192 if (count >= 2)
193 {
194 dst[0] = b1tob4_table[v & 0x03];
195 v >>= 2;
196 ++dst;
197 count -= 2;
198 }
199 if (count > 0)
200 dst[0] = b1tob4_table[v & 0x03] & 0x0f;
201 }
202
203 static void convert_b1_to_b8(uint8_t *dst, const uint8_t *src, size_t count)
204 {
205 uint8_t v;
206 for ( ; count >= 8; count -= 8)
207 {
208 v = *(src++);
209 dst[0] = (~(v & 1)) + 1;
210 dst[1] = (~((v >> 1) & 1) + 1);
211 dst[2] = (~((v >> 2) & 1) + 1);
212 dst[3] = (~((v >> 3) & 1) + 1);
213 dst[4] = (~((v >> 4) & 1) + 1);
214 dst[5] = (~((v >> 5) & 1) + 1);
215 dst[6] = (~((v >> 6) & 1) + 1);
216 dst[7] = (~((v >> 7) & 1) + 1);
217 dst += 8;
218 }
219 if (count <= 0)
220 return;
221
222 v = *src;
223 for (; count > 0; --count)
224 {
225 *(dst++) = (~(v & 1)) + 1;
226 v >>= 1;
227 }
228 }
229
230 static void convert_b1_to_rgb888(uint8_t *dst, const uint8_t *src, size_t count)
231 {
232 uint8_t v, c;
233 for (; count >= 8; count -= 8)
234 {
235 v = *(src++);
236 for (size_t j=0; j<8; ++j, v >>= 1)
237 {
238 c = ~(v & 1) + 1;
239 dst[0] = c;
240 dst[1] = c;
241 dst[2] = c;
242 dst += 3;
243 }
244 }
245
246 if (count <= 0)
247 return;
248
249 v = *(src++);
250 for ( ; count > 0 ; --count, v >>= 1)
251 {
252 c = ~(v & 1) + 1;
253 dst[0] = c;
254 dst[1] = c;
255 dst[2] = c;
256 dst += 3;
257 }
258 }
259
260 static void convert_g1_to_rgba8888(uint8_t *dst, const uint8_t *src, size_t count)
261 {
262 uint8_t v, c;
263
264 for (; count >= 8; count -= 8)
265 {
266 v = *(src++);
267 for (size_t j=0; j<8; ++j, v >>= 1)
268 {
269 c = ~(v & 1) + 1;
270 dst[0] = c;
271 dst[1] = c;
272 dst[2] = c;
273 dst[3] = 0xff;
274 dst += 4;
275 }
276 }
277
278 if (count <= 0)
279 return;
280
281 v = *(src++);
282 for ( ; count > 0 ; --count, v >>= 1)
283 {
284 c = ~(v & 1) + 1;
285 dst[0] = c;
286 dst[1] = c;
287 dst[2] = c;
288 dst[3] = 0xff;
289 dst += 4;
290 }
291 }
292
293 static void convert_a1_to_rgba8888(uint8_t *dst, const uint8_t *src, size_t count)
294 {
295 uint8_t v;
296 for (; count >= 8; count -= 8)
297 {
298 v = *(src++);
299 for (size_t j=0; j<8; ++j, v >>= 1)
300 {
301 dst[0] = 0xff;
302 dst[1] = 0xff;
303 dst[2] = 0xff;
304 dst[3] = ~(v & 1) + 1;
305
306 dst += 4;
307 }
308 }
309
310 if (count <= 0)
311 return;
312
313 v = *(src++);
314 for ( ; count > 0 ; --count, v >>= 1)
315 {
316 dst[0] = 0xff;
317 dst[1] = 0xff;
318 dst[2] = 0xff;
319 dst[3] = ~(v & 1) + 1;
320 dst += 4;
321 }
322 }
323
324 static void convert_b1_to_prgba8888(uint8_t *dptr, const uint8_t *src, size_t count)
325 {
326 uint32_t v;
327 uint32_t *dst = reinterpret_cast<uint32_t *>(dptr);
328
329 for (; count >= 8; count -= 8)
330 {
331 v = *(src++);
332 for (size_t j=0; j<8; ++j, v >>= 1)
333 *(dst++) = ~(v & 1) + 1;
334 }
335
336 if (count <= 0)
337 return;
338
339 v = *(src++);
340 for ( ; count > 0 ; --count, v >>= 1)
341 *(dst++) = ~(v & 1) + 1;
342 }
343
344 static pixel_conversion_t pixel_convert_function_for_g1(pixel_format_t dst_fmt) noexcept
345 {
346 switch (dst_fmt)
347 {
348 case PIXFMT_G2:
349 case PIXFMT_A2:
350 return convert_b1_to_b2;
351 case PIXFMT_G4:
352 case PIXFMT_A4:
353 return convert_b1_to_b4;
354 case PIXFMT_G8:
355 case PIXFMT_A8:
356 return convert_b1_to_b8;
357 case PIXFMT_RGB888:
358 case PIXFMT_BGR888:
359 return convert_b1_to_rgb888;
360 case PIXFMT_RGBA8888:
361 case PIXFMT_BGRA8888:
362 return convert_g1_to_rgba8888;
363 case PIXFMT_PRGBA8888:
364 case PIXFMT_PBGRA8888:
365 return convert_b1_to_prgba8888;
366
367 default:
368 break;
369 }
370 return NULL;
371 }
372
373 static pixel_conversion_t pixel_convert_function_for_a1(pixel_format_t dst_fmt) noexcept
374 {
375 switch (dst_fmt)
376 {
377 case PIXFMT_G2:
378 case PIXFMT_A2:
379 return convert_b1_to_b2;
380 case PIXFMT_G4:
381 case PIXFMT_A4:
382 return convert_b1_to_b4;
383 case PIXFMT_G8:
384 case PIXFMT_A8:
385 return convert_b1_to_b8;
386 case PIXFMT_RGB888:
387 case PIXFMT_BGR888:
388 return convert_b1_to_rgb888;
389 case PIXFMT_RGBA8888:
390 case PIXFMT_BGRA8888:
391 return convert_a1_to_rgba8888;
392 case PIXFMT_PRGBA8888:
393 case PIXFMT_PBGRA8888:
394 return convert_b1_to_prgba8888;
395
396 default:
397 break;
398 }
399 return NULL;
400 }
401
402 static void convert_b2_to_b1(uint8_t *dst, const uint8_t *src, size_t count)
403 {
404 uint16_t v;
405 for ( ; count >= 8; count -= 8)
406 {
407 v = src[0] | (uint16_t(src[1]) << 8);
408 v = ((v & 0x8888) >> 2) | ((v & 0x2222) >> 1);
409 v = (v & 0x0303) | ((v & 0x3030) >> 2);
410 *(dst++) = uint8_t((v & 0x0f) | (v >> 4));
411 src += 2;
412 }
413 if (count <= 0)
414 return;
415
416 v = src[0];
417 if (count >= 4)
418 v |= (uint16_t(src[1]) << 8);
419
420 uint16_t c = 0;
421 for (size_t i=0; i<count; ++i)
422 c |= ((v >> (i*2 + 1)) & 1) << i;
423
424 *dst = uint8_t(c);
425 }
426
427 static const uint8_t b2tob4_table[] =
428 {
429 0x00, 0x05, 0x0a, 0x0f,
430 0x50, 0x55, 0x5a, 0x5f,
431 0xa0, 0xa5, 0xaa, 0xaf,
432 0xf0, 0xf5, 0xfa, 0xff,
433 };
434
435 static void convert_b2_to_b4(uint8_t *dst, const uint8_t *src, size_t count)
436 {
437 uint8_t v;
438 for ( ; count >= 4; count -= 4)
439 {
440 v = *(src++);
441 dst[0] = b2tob4_table[v & 0x0f];
442 dst[1] = b2tob4_table[v >> 4];
443 dst += 2;
444 }
445 if (count <= 0)
446 return;
447
448 v = *src;
449 if (count >= 2)
450 {
451 *(dst++) = b2tob4_table[v & 0x0f];
452 count -= 2;
453 v >>= 4;
454 }
455
456 if (count > 0)
457 *dst = b2tob4_table[v & 0x03];
458 }
459
460 static const uint8_t b2tob8_table[] =
461 {
462 0x00, 0x55, 0xaa, 0xff
463 };
464
465 static void convert_b2_to_b8(uint8_t *dst, const uint8_t *src, size_t count)
466 {
467 uint8_t v;
468 for ( ; count >= 4; count -= 4)
469 {
470 v = *(src++);
471 dst[0] = b2tob8_table[v & 0x03];
472 dst[1] = b2tob8_table[(v >> 2) & 0x03];
473 dst[2] = b2tob8_table[(v >> 4) & 0x03];
474 dst[3] = b2tob8_table[(v >> 6) & 0x03];
475 dst += 4;
476 }
477 if (count <= 0)
478 return;
479
480 v = *(src++);
481 for ( ; count > 0; --count)
482 {
483 *(dst++) = b2tob8_table[v & 0x03];
484 v >>= 2;
485 }
486 }
487
488 static void convert_b2_to_r8b8g8(uint8_t *dst, const uint8_t *src, size_t count)
489 {
490 uint8_t v, c;
491 for (; count >= 4; count -= 4)
492 {
493 v = *(src++);
494
495 c = b2tob8_table[v & 0x03];
496 dst[0] = c;
497 dst[1] = c;
498 dst[2] = c;
499
500 c = b2tob8_table[(v >> 2) & 0x03];
501 dst[3] = c;
502 dst[4] = c;
503 dst[5] = c;
504
505 c = b2tob8_table[(v >> 4) & 0x03];
506 dst[6] = c;
507 dst[7] = c;
508 dst[8] = c;
509
510 c = b2tob8_table[v >> 6];
511 dst[9] = c;
512 dst[10] = c;
513 dst[11] = c;
514
515 dst += 12;
516 }
517
518 if (count <= 0)
519 return;
520
521 v = *src;
522 for ( ; count > 0 ; --count)
523 {
524 c = b2tob8_table[v & 0x03];
525 dst[0] = c;
526 dst[1] = c;
527 dst[2] = c;
528 dst += 3;
529 v >>= 2;
530 }
531 }
532
533 static const uint32_t g2tor8b8g8a8_table[] =
534 {
535 __IF_LE(0xff000000, 0xff555555, 0xffaaaaaa, 0xffffffff,)
536 __IF_BE(0x000000ff, 0x555555ff, 0xaaaaaaff, 0xffffffff,)
537 };
538
539 static void convert_g2_to_r8b8g8a8(uint8_t *dptr, const uint8_t *src, size_t count)
540 {
541 uint8_t v;
542 uint32_t *dst = reinterpret_cast<uint32_t *>(dptr);
543 for (; count >= 4; count -= 4)
544 {
545 v = *(src++);
546 dst[0] = g2tor8b8g8a8_table[v & 0x03];
547 dst[1] = g2tor8b8g8a8_table[(v >> 2) & 0x03];
548 dst[2] = g2tor8b8g8a8_table[(v >> 4) & 0x03];
549 dst[3] = g2tor8b8g8a8_table[v >> 6];
550 dst += 4;
551 }
552
553 if (count <= 0)
554 return;
555
556 v = *src;
557 for ( ; count > 0 ; --count)
558 {
559 *(dst++) = g2tor8b8g8a8_table[v & 0x03];
560 v >>= 2;
561 }
562 }
563
564 static const uint32_t a2tor8b8g8a8_table[] =
565 {
566 __IF_LE(0x00ffffff, 0x55ffffff, 0xaaffffff, 0xffffffff,)
567 __IF_BE(0xffffff00, 0xffffff55, 0xffffffaa, 0xffffffff,)
568 };
569
570 static void convert_a2_to_r8b8g8a8(uint8_t *dptr, const uint8_t *src, size_t count)
571 {
572 uint8_t v;
573 uint32_t *dst = reinterpret_cast<uint32_t *>(dptr);
574 for (; count >= 4; count -= 4)
575 {
576 v = *(src++);
577 dst[0] = a2tor8b8g8a8_table[v & 0x03];
578 dst[1] = a2tor8b8g8a8_table[(v >> 2) & 0x03];
579 dst[2] = a2tor8b8g8a8_table[(v >> 4) & 0x03];
580 dst[3] = a2tor8b8g8a8_table[v >> 6];
581 dst += 4;
582 }
583
584 if (count <= 0)
585 return;
586
587 v = *src;
588 for ( ; count > 0 ; --count)
589 {
590 *(dst++) = a2tor8b8g8a8_table[v & 0x03];
591 v >>= 2;
592 }
593 }
594
595 static const uint32_t a2topr8b8g8a8_table[] =
596 {
597 0x00000000, 0x55555555, 0xaaaaaaaa, 0xffffffff,
598 };
599
600 static void convert_a2_to_pr8b8g8a8(uint8_t *dptr, const uint8_t *src, size_t count)
601 {
602 uint8_t v;
603 uint32_t *dst = reinterpret_cast<uint32_t *>(dptr);
604 for (; count >= 4; count -= 4)
605 {
606 v = *(src++);
607 dst[0] = a2topr8b8g8a8_table[v & 0x03];
608 dst[1] = a2topr8b8g8a8_table[(v >> 2) & 0x03];
609 dst[2] = a2topr8b8g8a8_table[(v >> 4) & 0x03];
610 dst[3] = a2topr8b8g8a8_table[v >> 6];
611 dst += 4;
612 }
613
614 if (count <= 0)
615 return;
616
617 v = *src;
618 for ( ; count > 0 ; --count)
619 {
620 *(dst++) = a2topr8b8g8a8_table[v & 0x03];
621 v >>= 2;
622 }
623 }
624
625 static pixel_conversion_t pixel_convert_function_for_g2(pixel_format_t dst_fmt) noexcept
626 {
627 switch (dst_fmt)
628 {
629 case PIXFMT_G1:
630 case PIXFMT_A1:
631 return convert_b2_to_b1;
632 case PIXFMT_G4:
633 case PIXFMT_A4:
634 return convert_b2_to_b4;
635 case PIXFMT_G8:
636 case PIXFMT_A8:
637 return convert_b2_to_b8;
638 case PIXFMT_RGB888:
639 case PIXFMT_BGR888:
640 return convert_b2_to_r8b8g8;
641 case PIXFMT_RGBA8888:
642 case PIXFMT_BGRA8888:
643 case PIXFMT_PRGBA8888:
644 case PIXFMT_PBGRA8888:
645 return convert_g2_to_r8b8g8a8;
646
647 default:
648 break;
649 }
650 return NULL;
651 }
652
653 static pixel_conversion_t pixel_convert_function_for_a2(pixel_format_t dst_fmt) noexcept
654 {
655 switch (dst_fmt)
656 {
657 case PIXFMT_G1:
658 case PIXFMT_A1:
659 return convert_b2_to_b1;
660 case PIXFMT_G4:
661 case PIXFMT_A4:
662 return convert_b2_to_b4;
663 case PIXFMT_G8:
664 case PIXFMT_A8:
665 return convert_b2_to_b8;
666 case PIXFMT_RGB888:
667 case PIXFMT_BGR888:
668 return convert_b2_to_r8b8g8;
669 case PIXFMT_RGBA8888:
670 case PIXFMT_BGRA8888:
671 return convert_a2_to_r8b8g8a8;
672 case PIXFMT_PRGBA8888:
673 case PIXFMT_PBGRA8888:
674 return convert_a2_to_pr8b8g8a8;
675
676 default:
677 break;
678 }
679 return NULL;
680 }
681
682 static void convert_b4_to_b1(uint8_t *dst, const uint8_t *src, size_t count)
683 {
684 uint8_t v, a, b, c, d;
685 for ( ; count >= 8; count -= 8)
686 {
687 a = src[0];
688 b = src[1];
689 c = src[2];
690 d = src[3];
691
692 *(dst++) =
693 ((a & 0x08) >> 3) | ((a & 0x80) >> 6) |
694 ((b & 0x08) >> 1) | ((b & 0x80) >> 4) |
695 ((c & 0x08) << 1) | ((c & 0x80) >> 2) |
696 ((d & 0x08) << 3) | (d & 0x80);
697
698 src += 4;
699 }
700 if (count <= 0)
701 return;
702
703 v = 0;
704 d = 0;
705 if (count >= 4)
706 {
707 a = src[0];
708 b = src[1];
709 v |=
710 ((a & 0x08) >> 3) | ((a & 0x80) >> 6) |
711 ((b & 0x08) >> 1) | ((b & 0x80) >> 4);
712 count -= 4;
713 d += 4;
714 src += 2;
715 }
716 if (count >= 2)
717 {
718 a = *(src++);
719 v |= (((a & 0x08) >> 3) | ((a & 0x80) >> 6)) << d;
720 count -= 2;
721 d += 2;
722 }
723 if (count >= 1)
724 {
725 a = *src;
726 v |= ((a & 0x08) >> 3) << d;
727 }
728
729 *dst = v;
730 }
731
732 static void convert_b4_to_b2(uint8_t *dst, const uint8_t *src, size_t count)
733 {
734 uint8_t v, a, b;
735 for ( ; count >= 4; count -= 4)
736 {
737 a = src[0];
738 b = src[1];
739
740 *(dst++) =
741 ((a & 0x0c) >> 2) | ((a & 0xc0) >> 4) |
742 ((b & 0x0c) << 2) | (b & 0xc0);
743
744 src += 2;
745 }
746 if (count <= 0)
747 return;
748
749 v = 0;
750 b = 0;
751 if (count >= 2)
752 {
753 a = *(src++);
754 v |= ((a & 0x0c) >> 2) | ((a & 0xc0) >> 4);
755 b += 4;
756 count -= 2;
757 }
758 if (count >= 1)
759 {
760 a = *src;
761 v |= ((a & 0x0c) >> 2) << b;
762 }
763
764 *dst = v;
765 }
766
767 static const uint8_t b4tob8_table[] =
768 {
769 0x00, 0x11, 0x22, 0x33,
770 0x44, 0x55, 0x66, 0x77,
771 0x88, 0x99, 0xaa, 0xbb,
772 0xcc, 0xdd, 0xee, 0xff
773 };
774
775 static void convert_b4_to_b8(uint8_t *dst, const uint8_t *src, size_t count)
776 {
777 uint8_t v;
778 for ( ; count >= 2; count -= 2)
779 {
780 v = *(src++);
781 dst[0] = b4tob8_table[v & 0x0f];
782 dst[1] = b4tob8_table[v >> 4];
783 dst += 2;
784 }
785 if (count <= 0)
786 return;
787
788 v = *src;
789 *dst = b4tob8_table[v & 0x0f];
790 }
791
792 static void convert_b4_to_rgb888(uint8_t *dst, const uint8_t *src, size_t count)
793 {
794 uint8_t v, c1, c2;
795 for (; count >= 2; count -= 2)
796 {
797 v = *(src++);
798 c1 = b4tob8_table[v & 0x0f];
799 c2 = b4tob8_table[v >> 4];
800 dst[0] = c1;
801 dst[1] = c1;
802 dst[2] = c1;
803 dst[3] = c2;
804 dst[4] = c2;
805 dst[5] = c2;
806 dst += 6;
807 }
808
809 if (count <= 0)
810 return;
811
812 v = *src++;
813 c1 = b4tob8_table[v & 0x0f];
814 dst[0] = c1;
815 dst[1] = c1;
816 dst[2] = c1;
817 }
818
819 static const uint32_t g4tor8b8g8a8_table[] =
820 {
821 __IF_LE(
822 0xff000000, 0xff111111, 0xff222222, 0xff333333,
823 0xff444444, 0xff555555, 0xff666666, 0xff777777,
824 0xff888888, 0xff999999, 0xffaaaaaa, 0xffbbbbbb,
825 0xffcccccc, 0xffdddddd, 0xffeeeeee, 0xffffffff,
826 )
827 __IF_BE(
828 0x000000ff, 0x111111ff, 0x222222ff, 0x333333ff,
829 0x444444ff, 0x555555ff, 0x666666ff, 0x777777ff,
830 0x888888ff, 0x999999ff, 0xaaaaaaff, 0xbbbbbbff,
831 0xccccccff, 0xddddddff, 0xeeeeeeff, 0xffffffff,
832 )
833 };
834
835 static void convert_g4_to_rgba8888(uint8_t *dptr, const uint8_t *src, size_t count)
836 {
837 uint8_t v;
838 uint32_t *dst = reinterpret_cast<uint32_t *>(dptr);
839 for (; count >= 2; count -= 2)
840 {
841 v = *(src++);
842 dst[0] = g4tor8b8g8a8_table[v & 0x0f];
843 dst[1] = g4tor8b8g8a8_table[v >> 4];
844 dst += 2;
845 }
846
847 if (count <= 0)
848 return;
849
850 v = *src++;
851 dst[0] = g4tor8b8g8a8_table[v & 0x0f];
852 }
853
854 static const uint32_t a4tor8b8g8a8_table[] =
855 {
856 __IF_LE(
857 0x00ffffff, 0x11ffffff, 0x22ffffff, 0x33ffffff,
858 0x44ffffff, 0x55ffffff, 0x66ffffff, 0x77ffffff,
859 0x88ffffff, 0x99ffffff, 0xaaffffff, 0xbbffffff,
860 0xccffffff, 0xddffffff, 0xeeffffff, 0xffffffff,
861 )
862 __IF_BE(
863 0xffffff00, 0xffffff11, 0xffffff22, 0xffffff33,
864 0xffffff44, 0xffffff55, 0xffffff66, 0xffffff77,
865 0xffffff88, 0xffffff99, 0xffffffaa, 0xffffffbb,
866 0xffffffcc, 0xffffffdd, 0xffffffee, 0xffffffff,
867 )
868 };
869
870 static void convert_a4_to_rgba8888(uint8_t *dptr, const uint8_t *src, size_t count)
871 {
872 uint8_t v;
873 uint32_t *dst = reinterpret_cast<uint32_t *>(dptr);
874 for (; count >= 2; count -= 2)
875 {
876 v = *(src++);
877 dst[0] = a4tor8b8g8a8_table[v & 0x0f];
878 dst[1] = a4tor8b8g8a8_table[v >> 4];
879 dst += 2;
880 }
881
882 if (count <= 0)
883 return;
884
885 v = *src++;
886 dst[0] = a4tor8b8g8a8_table[v & 0x0f];
887 }
888
889 static const uint32_t a4topr8b8g8a8_table[] =
890 {
891 0x00000000, 0x11111111, 0x22222222, 0x33333333,
892 0x44444444, 0x55555555, 0x66666666, 0x77777777,
893 0x88888888, 0x99999999, 0xaaaaaaaa, 0xbbbbbbbb,
894 0xcccccccc, 0xdddddddd, 0xeeeeeeee, 0xffffffff,
895 };
896
897 static void convert_a4_to_prgba8888(uint8_t *dptr, const uint8_t *src, size_t count)
898 {
899 uint8_t v;
900 uint32_t *dst = reinterpret_cast<uint32_t *>(dptr);
901 for (; count >= 2; count -= 2)
902 {
903 v = *(src++);
904 dst[0] = a4topr8b8g8a8_table[v & 0x0f];
905 dst[1] = a4topr8b8g8a8_table[v >> 4];
906 dst += 2;
907 }
908
909 if (count <= 0)
910 return;
911
912 v = *src++;
913 dst[0] = a4topr8b8g8a8_table[v & 0x0f];
914 }
915
916 static pixel_conversion_t pixel_convert_function_for_g4(pixel_format_t dst_fmt) noexcept
917 {
918 switch (dst_fmt)
919 {
920 case PIXFMT_G1:
921 case PIXFMT_A1:
922 return convert_b4_to_b1;
923 case PIXFMT_G2:
924 case PIXFMT_A2:
925 return convert_b4_to_b2;
926 case PIXFMT_G8:
927 case PIXFMT_A8:
928 return convert_b4_to_b8;
929 case PIXFMT_RGB888:
930 case PIXFMT_BGR888:
931 return convert_b4_to_rgb888;
932 case PIXFMT_RGBA8888:
933 case PIXFMT_BGRA8888:
934 return convert_g4_to_rgba8888;
935 case PIXFMT_PRGBA8888:
936 case PIXFMT_PBGRA8888:
937 return convert_g4_to_rgba8888;
938
939 default:
940 break;
941 }
942 return NULL;
943 }
944
945 static pixel_conversion_t pixel_convert_function_for_a4(pixel_format_t dst_fmt) noexcept
946 {
947 switch (dst_fmt)
948 {
949 case PIXFMT_G1:
950 case PIXFMT_A1:
951 return convert_b4_to_b1;
952 case PIXFMT_G2:
953 case PIXFMT_A2:
954 return convert_b4_to_b2;
955 case PIXFMT_G8:
956 case PIXFMT_A8:
957 return convert_b4_to_b8;
958 case PIXFMT_RGB888:
959 case PIXFMT_BGR888:
960 return convert_b4_to_rgb888;
961 case PIXFMT_RGBA8888:
962 case PIXFMT_BGRA8888:
963 return convert_a4_to_rgba8888;
964 case PIXFMT_PRGBA8888:
965 case PIXFMT_PBGRA8888:
966 return convert_a4_to_prgba8888;
967
968 default:
969 break;
970 }
971 return NULL;
972 }
973
974 static void convert_b8_to_b1(uint8_t *dst, const uint8_t *src, size_t count)
975 {
976 uint8_t v, c;
977 for ( ; count >= 8; count -= 8)
978 {
979 *(dst++) =
980 (src[0] >> 7) |
981 ((src[1] & 0x80) >> 6) |
982 ((src[2] & 0x80) >> 5) |
983 ((src[3] & 0x80) >> 4) |
984 ((src[4] & 0x80) >> 3) |
985 ((src[5] & 0x80) >> 2) |
986 ((src[6] & 0x80) >> 1) |
987 (src[7] & 0x80);
988 src += 8;
989 }
990 if (count <= 0)
991 return;
992
993 v = 0;
994 c = 0;
995 if (count >= 4)
996 {
997 v |=
998 (src[0] >> 7) |
999 ((src[1] & 0x80) >> 6) |
1000 ((src[2] & 0x80) >> 5) |
1001 ((src[3] & 0x80) >> 4);
1002 src += 4;
1003 c += 4;
1004 count -= 4;
1005 }
1006 if (count >= 2)
1007 {
1008 v |=
1009 ((src[0] >> 7) |
1010 ((src[1] & 0x80) >> 6)) << c;
1011 src += 2;
1012 c += 2;
1013 count -= 2;
1014 }
1015 if (count >= 1)
1016 {
1017 v |= (src[0] >> 7) << c;
1018 }
1019 *dst = v;
1020 }
1021
1022 static void convert_b8_to_b2(uint8_t *dst, const uint8_t *src, size_t count)
1023 {
1024 uint8_t v, c;
1025 for ( ; count >= 4; count -= 4)
1026 {
1027 *(dst++) =
1028 (src[0] >> 6) |
1029 ((src[1] & 0xc0) >> 4) |
1030 ((src[2] & 0xc0) >> 2) |
1031 (src[3] & 0xc0);
1032 src += 4;
1033 }
1034 if (count <= 0)
1035 return;
1036
1037 v = 0;
1038 c = 0;
1039 if (count >= 2)
1040 {
1041 v |=
1042 (src[0] >> 6) |
1043 ((src[1] & 0xc0) >> 4);
1044 src += 2;
1045 count -= 2;
1046 c += 4;
1047 }
1048 if (count >= 1)
1049 v |= (src[0] >> 6) << c;
1050 *dst = v;
1051 }
1052
1053 static void convert_b8_to_b4(uint8_t *dst, const uint8_t *src, size_t count)
1054 {
1055 uint8_t c;
1056 for ( ; count >= 2; count -= 2)
1057 {
1058 *(dst++) =
1059 (src[0] >> 4) |
1060 (src[1] & 0xf0);
1061 src += 2;
1062 }
1063 if (count <= 0)
1064 return;
1065
1066 c = src[0];
1067 *dst = c >> 4;
1068 }
1069
1070 static void convert_b8_to_rgb888(uint8_t *dst, const uint8_t *src, size_t count)
1071 {
1072 uint8_t v;
1073 for (; count > 0; --count)
1074 {
1075 v = *(src++);
1076 dst[0] = v;
1077 dst[1] = v;
1078 dst[2] = v;
1079 dst += 3;
1080 }
1081 }
1082
1083 static void convert_g8_to_rgba8888(uint8_t *dst, const uint8_t *src, size_t count)
1084 {
1085 uint8_t v;
1086 for (; count > 0; --count)
1087 {
1088 v = *(src++);
1089 dst[0] = v;
1090 dst[1] = v;
1091 dst[2] = v;
1092 dst[3] = 0xff;
1093 dst += 4;
1094 }
1095 }
1096
1097 static void convert_a8_to_rgba8888(uint8_t *dst, const uint8_t *src, size_t count)
1098 {
1099 uint8_t v;
1100 for (; count > 0; --count)
1101 {
1102 v = *(src++);
1103 dst[0] = 0xff;
1104 dst[1] = 0xff;
1105 dst[2] = 0xff;
1106 dst[3] = v;
1107 dst += 4;
1108 }
1109 }
1110
1111 static void convert_a8_to_prgba8888(uint8_t *dst, const uint8_t *src, size_t count)
1112 {
1113 uint8_t v;
1114 for (; count > 0; --count)
1115 {
1116 v = *(src++);
1117 dst[0] = v;
1118 dst[1] = v;
1119 dst[2] = v;
1120 dst[3] = v;
1121 dst += 4;
1122 }
1123 }
1124
1125 static pixel_conversion_t pixel_convert_function_for_g8(pixel_format_t dst_fmt) noexcept
1126 {
1127 switch (dst_fmt)
1128 {
1129 case PIXFMT_G1:
1130 case PIXFMT_A1:
1131 return convert_b8_to_b1;
1132 case PIXFMT_G2:
1133 case PIXFMT_A2:
1134 return convert_b8_to_b2;
1135 case PIXFMT_G4:
1136 case PIXFMT_A4:
1137 return convert_b8_to_b4;
1138 case PIXFMT_RGB888:
1139 case PIXFMT_BGR888:
1140 return convert_b8_to_rgb888;
1141 case PIXFMT_RGBA8888:
1142 case PIXFMT_BGRA8888:
1143 case PIXFMT_PRGBA8888:
1144 case PIXFMT_PBGRA8888:
1145 return convert_g8_to_rgba8888;
1146
1147 default:
1148 break;
1149 }
1150 return NULL;
1151 }
1152
1153 static pixel_conversion_t pixel_convert_function_for_a8(pixel_format_t dst_fmt) noexcept
1154 {
1155 switch (dst_fmt)
1156 {
1157 case PIXFMT_G1:
1158 case PIXFMT_A1:
1159 return convert_b8_to_b1;
1160 case PIXFMT_G2:
1161 case PIXFMT_A2:
1162 return convert_b8_to_b2;
1163 case PIXFMT_G4:
1164 case PIXFMT_A4:
1165 return convert_b8_to_b4;
1166 case PIXFMT_RGB888:
1167 case PIXFMT_BGR888:
1168 return convert_b8_to_rgb888;
1169 case PIXFMT_RGBA8888:
1170 case PIXFMT_BGRA8888:
1171 return convert_a8_to_rgba8888;
1172 case PIXFMT_PRGBA8888:
1173 case PIXFMT_PBGRA8888:
1174 return convert_a8_to_prgba8888;
1175
1176 default:
1177 break;
1178 }
1179 return NULL;
1180 }
1181
1182 static inline const uint8_t lightness(uint8_t r, uint8_t g, uint8_t b)
1183 {
1184 const uint16_t cmax = lsp_max(r, g, b);
1185 const uint16_t cmin = lsp_min(r, g, b);
1186 return uint8_t((cmax + cmin) >> 1);
1187 }
1188
1189 static void convert_rgb888_to_b1(uint8_t *dst, const uint8_t *src, size_t count)
1190 {
1191 uint8_t v;
1192 for ( ; count >= 8; count -= 8)
1193 {
1194 *(dst++) =
1195 (lightness(src[0], src[1], src[2]) >> 7) |
1196 ((lightness(src[3], src[4], src[5]) & 0x80) >> 6) |
1197 ((lightness(src[6], src[7], src[8]) & 0x80) >> 5) |
1198 ((lightness(src[9], src[10], src[11]) & 0x80) >> 4) |
1199 ((lightness(src[12], src[13], src[14]) & 0x80) >> 3) |
1200 ((lightness(src[15], src[16], src[17]) & 0x80) >> 2) |
1201 ((lightness(src[18], src[18], src[20]) & 0x80) >> 1) |
1202 (lightness(src[21], src[22], src[23]) & 0x80);
1203 src += 24;
1204 }
1205 if (count <= 0)
1206 return;
1207
1208 v = 0;
1209 for (size_t i=0; i<count; ++i)
1210 {
1211 v |= (lightness(src[0], src[1], src[2]) >> 7) << i;
1212 src += 3;
1213 }
1214 *(dst++) = v;
1215 }
1216
1217 static void convert_rgb888_to_b2(uint8_t *dst, const uint8_t *src, size_t count)
1218 {
1219 uint8_t v;
1220 for ( ; count >= 4; count -= 4)
1221 {
1222 *(dst++) =
1223 (lightness(src[0], src[1], src[2]) >> 6) |
1224 ((lightness(src[3], src[4], src[5]) & 0xc0) >> 4) |
1225 ((lightness(src[6], src[7], src[8]) & 0xc0) >> 2) |
1226 (lightness(src[9], src[10], src[11]) & 0xc0);
1227 src += 12;
1228 }
1229 if (count <= 0)
1230 return;
1231
1232 v = 0;
1233 for (size_t i=0; i<count; ++i)
1234 {
1235 v |= (lightness(src[0], src[1], src[2]) >> 6) << (i*2);
1236 src += 3;
1237 }
1238 *(dst++) = v;
1239 }
1240
1241 static void convert_rgb888_to_b4(uint8_t *dst, const uint8_t *src, size_t count)
1242 {
1243 for ( ; count >= 2; count -= 2)
1244 {
1245 *(dst++) =
1246 (lightness(src[0], src[1], src[2]) >> 4) |
1247 (lightness(src[3], src[4], src[5]) & 0xf0);
1248 src += 6;
1249 }
1250 if (count <= 0)
1251 return;
1252
1253 *dst = lightness(src[0], src[1], src[2]) >> 4;
1254 }
1255
1256 static void convert_rgb888_to_b8(uint8_t *dst, const uint8_t *src, size_t count)
1257 {
1258 for ( ; count > 0; --count)
1259 {
1260 *(dst++) = lightness(src[0], src[1], src[2]);
1261 src += 3;
1262 }
1263 }
1264
1265 static void convert_rgb888_to_bgr888(uint8_t *dst, const uint8_t *src, size_t count)
1266 {
1267 for ( ; count > 0; --count)
1268 {
1269 dst[0] = src[2];
1270 dst[1] = src[1];
1271 dst[2] = src[0];
1272 src += 3;
1273 dst += 3;
1274 }
1275 }
1276
1277 static void convert_rgb888_to_rgba8888(uint8_t *dst, const uint8_t *src, size_t count)
1278 {
1279 for ( ; count > 0; --count)
1280 {
1281 dst[0] = src[0];
1282 dst[1] = src[1];
1283 dst[2] = src[2];
1284 dst[3] = 0xff;
1285 src += 3;
1286 dst += 4;
1287 }
1288 }
1289
1290 static void convert_rgb888_to_bgra8888(uint8_t *dst, const uint8_t *src, size_t count)
1291 {
1292 for ( ; count > 0; --count)
1293 {
1294 dst[0] = src[2];
1295 dst[1] = src[1];
1296 dst[2] = src[0];
1297 dst[3] = 0xff;
1298 src += 3;
1299 dst += 4;
1300 }
1301 }
1302
1303 static void convert_bgr888_to_rgba8888(uint8_t *dst, const uint8_t *src, size_t count)
1304 {
1305 for ( ; count > 0; --count)
1306 {
1307 dst[0] = src[2];
1308 dst[1] = src[1];
1309 dst[2] = src[0];
1310 dst[3] = 0xff;
1311 src += 3;
1312 dst += 4;
1313 }
1314 }
1315
1316 static pixel_conversion_t pixel_convert_function_for_rgb888(pixel_format_t dst_fmt) noexcept
1317 {
1318 switch (dst_fmt)
1319 {
1320 case PIXFMT_G1:
1321 case PIXFMT_A1:
1322 return convert_rgb888_to_b1;
1323 case PIXFMT_G2:
1324 case PIXFMT_A2:
1325 return convert_rgb888_to_b2;
1326 case PIXFMT_G4:
1327 case PIXFMT_A4:
1328 return convert_rgb888_to_b4;
1329 case PIXFMT_G8:
1330 case PIXFMT_A8:
1331 return convert_rgb888_to_b8;
1332 case PIXFMT_BGR888:
1333 return convert_rgb888_to_bgr888;
1334 case PIXFMT_RGBA8888:
1335 case PIXFMT_PRGBA8888:
1336 return convert_rgb888_to_rgba8888;
1337
1338 case PIXFMT_BGRA8888:
1339 case PIXFMT_PBGRA8888:
1340 return convert_rgb888_to_bgra8888;
1341
1342 default:
1343 break;
1344 }
1345 return NULL;
1346 }
1347
1348 static pixel_conversion_t pixel_convert_function_for_bgr888(pixel_format_t dst_fmt) noexcept
1349 {
1350 switch (dst_fmt)
1351 {
1352 case PIXFMT_G1:
1353 case PIXFMT_A1:
1354 return convert_rgb888_to_b1;
1355 case PIXFMT_G2:
1356 case PIXFMT_A2:
1357 return convert_rgb888_to_b2;
1358 case PIXFMT_G4:
1359 case PIXFMT_A4:
1360 return convert_rgb888_to_b4;
1361 case PIXFMT_G8:
1362 case PIXFMT_A8:
1363 return convert_rgb888_to_b8;
1364 case PIXFMT_BGR888:
1365 return convert_rgb888_to_bgr888;
1366 case PIXFMT_RGBA8888:
1367 case PIXFMT_PRGBA8888:
1368 return convert_bgr888_to_rgba8888;
1369 case PIXFMT_BGRA8888:
1370 case PIXFMT_PBGRA8888:
1371 return convert_rgb888_to_rgba8888;
1372
1373 default:
1374 break;
1375 }
1376 return NULL;
1377 }
1378
1379 static void convert_rgba8888_to_g1(uint8_t *dst, const uint8_t *src, size_t count)
1380 {
1381 uint8_t v;
1382 for ( ; count >= 8; count -= 8)
1383 {
1384 *(dst++) =
1385 (lightness(src[0], src[1], src[2]) >> 7) |
1386 ((lightness(src[4], src[5], src[6]) & 0x80) >> 6) |
1387 ((lightness(src[8], src[9], src[10]) & 0x80) >> 5) |
1388 ((lightness(src[12], src[13], src[14]) & 0x80) >> 4) |
1389 ((lightness(src[16], src[17], src[18]) & 0x80) >> 3) |
1390 ((lightness(src[20], src[21], src[22]) & 0x80) >> 2) |
1391 ((lightness(src[24], src[25], src[26]) & 0x80) >> 1) |
1392 (lightness(src[28], src[29], src[30]) & 0x80);
1393 src += 32;
1394 }
1395 if (count <= 0)
1396 return;
1397
1398 v = 0;
1399 for (size_t i=0; i<count; ++i)
1400 {
1401 v |= (lightness(src[0], src[1], src[2]) >> 7) << i;
1402 src += 4;
1403 }
1404 *dst = v;
1405 }
1406
1407 static void convert_rgba8888_to_a1(uint8_t *dst, const uint8_t *src, size_t count)
1408 {
1409 uint8_t v;
1410 for ( ; count >= 8; count -= 8)
1411 {
1412 *(dst++) =
1413 (src[3] >> 7) |
1414 ((src[7] & 0x80) >> 6) |
1415 ((src[11] & 0x80) >> 5) |
1416 ((src[15] & 0x80) >> 4) |
1417 ((src[19] & 0x80) >> 3) |
1418 ((src[23] & 0x80) >> 2) |
1419 ((src[27] & 0x80) >> 1) |
1420 (src[31] & 0x80);
1421 src += 32;
1422 }
1423 if (count <= 0)
1424 return;
1425
1426 v = 0;
1427 for (size_t i=0; i<count; ++i)
1428 {
1429 v |= (src[3] >> 7) << i;
1430 src += 4;
1431 }
1432 *dst = v;
1433 }
1434
1435 static void convert_rgba8888_to_g2(uint8_t *dst, const uint8_t *src, size_t count)
1436 {
1437 uint8_t v;
1438 for ( ; count >= 4; count -= 4)
1439 {
1440 *(dst++) =
1441 (lightness(src[0], src[1], src[2]) >> 6) |
1442 ((lightness(src[4], src[5], src[6]) & 0xc0) >> 4) |
1443 ((lightness(src[8], src[9], src[10]) & 0xc0) >> 2) |
1444 (lightness(src[12], src[13], src[14]) & 0xc0);
1445 src += 16;
1446 }
1447 if (count <= 0)
1448 return;
1449
1450 v = 0;
1451 for (size_t i=0; i<count; ++i)
1452 {
1453 v |= (lightness(src[0], src[1], src[2]) >> 6) << (i*2);
1454 src += 4;
1455 }
1456 *dst = v;
1457 }
1458
1459 static void convert_rgba8888_to_a2(uint8_t *dst, const uint8_t *src, size_t count)
1460 {
1461 uint8_t v;
1462 for ( ; count >= 4; count -= 4)
1463 {
1464 *(dst++) =
1465 (src[3] >> 6) |
1466 ((src[7] & 0xc0) >> 4) |
1467 ((src[11] & 0xc0) >> 2) |
1468 (src[15] & 0xc0);
1469 src += 16;
1470 }
1471 if (count <= 0)
1472 return;
1473
1474 v = 0;
1475 for (size_t i=0; i<count; ++i)
1476 {
1477 v |= (src[3] >> 6) << (i*2);
1478 src += 4;
1479 }
1480 *dst = v;
1481 }
1482
1483 static void convert_rgba8888_to_g4(uint8_t *dst, const uint8_t *src, size_t count)
1484 {
1485 for ( ; count >= 2; count -= 2)
1486 {
1487 *(dst++) =
1488 (lightness(src[0], src[1], src[2]) >> 4) |
1489 (lightness(src[4], src[5], src[6]) & 0xf0);
1490 src += 8;
1491 }
1492 if (count <= 0)
1493 return;
1494
1495 *dst = lightness(src[0], src[1], src[2]) >> 4;
1496 }
1497
1498 static void convert_rgba8888_to_a4(uint8_t *dst, const uint8_t *src, size_t count)
1499 {
1500 for ( ; count >= 2; count -= 2)
1501 {
1502 *(dst++) =
1503 (src[3] >> 4) |
1504 (src[7] & 0xf0);
1505 src += 8;
1506 }
1507 if (count <= 0)
1508 return;
1509
1510 *dst = src[3] >> 4;
1511 }
1512
1513 static void convert_rgba8888_to_g8(uint8_t *dst, const uint8_t *src, size_t count)
1514 {
1515 for ( ; count > 0; --count)
1516 {
1517 *(dst++) = lightness(src[0], src[1], src[2]);
1518 src += 4;
1519 }
1520 }
1521
1522 static void convert_rgba8888_to_a8(uint8_t *dst, const uint8_t *src, size_t count)
1523 {
1524 for ( ; count > 0; --count)
1525 {
1526 *(dst++) = src[3];
1527 src += 4;
1528 }
1529 }
1530
1531 static void convert_rgba8888_to_rgb888(uint8_t *dst, const uint8_t *src, size_t count)
1532 {
1533 for ( ; count > 0; --count)
1534 {
1535 dst[0] = src[0];
1536 dst[1] = src[1];
1537 dst[2] = src[2];
1538 src += 4;
1539 dst += 3;
1540 }
1541 }
1542
1543 static void convert_rgba8888_to_bgr888(uint8_t *dst, const uint8_t *src, size_t count)
1544 {
1545 for ( ; count > 0; --count)
1546 {
1547 dst[0] = src[2];
1548 dst[1] = src[1];
1549 dst[2] = src[0];
1550 src += 4;
1551 dst += 3;
1552 }
1553 }
1554
1555 constexpr uint32_t k_alpha = 0x1011;
1556
1557 static void convert_rgba8888_to_prgba8888(uint8_t *dst, const uint8_t *src, size_t count)
1558 {
1559 uint32_t v;
1560 for ( ; count > 0; --count)
1561 {
1562 v = src[3] * k_alpha;
1563 dst[0] = uint8_t((v * src[0]) >> 20);
1564 dst[1] = uint8_t((v * src[1]) >> 20);
1565 dst[2] = uint8_t((v * src[2]) >> 20);
1566 dst[3] = src[3];
1567 src += 4;
1568 dst += 4;
1569 }
1570 }
1571
1572 static void convert_rgba8888_to_pbgra8888(uint8_t *dst, const uint8_t *src, size_t count)
1573 {
1574 uint32_t v;
1575 for ( ; count > 0; --count)
1576 {
1577 v = src[3] * k_alpha;
1578 dst[0] = uint8_t((v * src[2]) >> 20);
1579 dst[1] = uint8_t((v * src[1]) >> 20);
1580 dst[2] = uint8_t((v * src[0]) >> 20);
1581 dst[3] = src[3];
1582 src += 4;
1583 dst += 4;
1584 }
1585 }
1586
1587 static pixel_conversion_t pixel_convert_function_for_rgba8888(pixel_format_t dst_fmt) noexcept
1588 {
1589 switch (dst_fmt)
1590 {
1591 case PIXFMT_G1:
1592 return convert_rgba8888_to_g1;
1593 case PIXFMT_A1:
1594 return convert_rgba8888_to_a1;
1595 case PIXFMT_G2:
1596 return convert_rgba8888_to_g2;
1597 case PIXFMT_A2:
1598 return convert_rgba8888_to_a2;
1599 case PIXFMT_G4:
1600 return convert_rgba8888_to_g4;
1601 case PIXFMT_A4:
1602 return convert_rgba8888_to_a4;
1603 case PIXFMT_G8:
1604 return convert_rgba8888_to_g8;
1605 case PIXFMT_A8:
1606 return convert_rgba8888_to_a8;
1607 case PIXFMT_RGB888:
1608 return convert_rgba8888_to_rgb888;
1609 case PIXFMT_BGR888:
1610 return convert_rgba8888_to_bgr888;
1611 case PIXFMT_PRGBA8888:
1612 return convert_rgba8888_to_prgba8888;
1613 case PIXFMT_PBGRA8888:
1614 return convert_rgba8888_to_pbgra8888;
1615
1616 default:
1617 break;
1618 }
1619 return NULL;
1620 }
1621
1622 static pixel_conversion_t pixel_convert_function_for_bgra8888(pixel_format_t dst_fmt) noexcept
1623 {
1624 switch (dst_fmt)
1625 {
1626 case PIXFMT_G1:
1627 return convert_rgba8888_to_g1;
1628 case PIXFMT_A1:
1629 return convert_rgba8888_to_a1;
1630 case PIXFMT_G2:
1631 return convert_rgba8888_to_g2;
1632 case PIXFMT_A2:
1633 return convert_rgba8888_to_a2;
1634 case PIXFMT_G4:
1635 return convert_rgba8888_to_g4;
1636 case PIXFMT_A4:
1637 return convert_rgba8888_to_a4;
1638 case PIXFMT_G8:
1639 return convert_rgba8888_to_g8;
1640 case PIXFMT_A8:
1641 return convert_rgba8888_to_a8;
1642 case PIXFMT_RGB888:
1643 return convert_rgba8888_to_bgr888;
1644 case PIXFMT_BGR888:
1645 return convert_rgba8888_to_rgb888;
1646 case PIXFMT_PRGBA8888:
1647 return convert_rgba8888_to_pbgra8888;
1648 case PIXFMT_PBGRA8888:
1649 return convert_rgba8888_to_prgba8888;
1650
1651 default:
1652 break;
1653 }
1654 return NULL;
1655 }
1656
1657 static inline const uint8_t prgba_lightness(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
1658 {
1659 if (a <= 0)
1660 return 0;
1661
1662 const uint32_t k = 0xfffff / a;
1663 const uint32_t xr = (r * k) >> 12;
1664 const uint32_t xg = (g * k) >> 12;
1665 const uint32_t xb = (b * k) >> 12;
1666 const uint32_t cmax = lsp_max(xr, xg, xb);
1667 const uint32_t cmin = lsp_min(xr, xg, xb);
1668 return uint8_t((cmax + cmin) >> 1);
1669 }
1670
1671 static void convert_prgba8888_to_g1(uint8_t *dst, const uint8_t *src, size_t count)
1672 {
1673 uint8_t v;
1674 for ( ; count >= 8; count -= 8)
1675 {
1676 *(dst++) =
1677 (prgba_lightness(src[0], src[1], src[2], src[3]) >> 7) |
1678 ((prgba_lightness(src[4], src[5], src[6], src[7]) & 0x80) >> 6) |
1679 ((prgba_lightness(src[8], src[9], src[10], src[11]) & 0x80) >> 5) |
1680 ((prgba_lightness(src[12], src[13], src[14], src[15]) & 0x80) >> 4) |
1681 ((prgba_lightness(src[16], src[17], src[18], src[19]) & 0x80) >> 3) |
1682 ((prgba_lightness(src[20], src[21], src[22], src[23]) & 0x80) >> 2) |
1683 ((prgba_lightness(src[24], src[25], src[26], src[27]) & 0x80) >> 1) |
1684 (prgba_lightness(src[28], src[29], src[30], src[31]) & 0x80);
1685 src += 32;
1686 }
1687 if (count <= 0)
1688 return;
1689
1690 v = 0;
1691 for (size_t i=0; i<count; ++i)
1692 {
1693 v |= (prgba_lightness(src[0], src[1], src[2], src[3]) >> 7) << i;
1694 src += 4;
1695 }
1696 *dst = v;
1697 }
1698
1699 static void convert_prgba8888_to_g2(uint8_t *dst, const uint8_t *src, size_t count)
1700 {
1701 uint8_t v;
1702 for ( ; count >= 4; count -= 4)
1703 {
1704 *(dst++) =
1705 (prgba_lightness(src[0], src[1], src[2], src[3]) >> 6) |
1706 ((prgba_lightness(src[4], src[5], src[6], src[7]) & 0xc0) >> 4) |
1707 ((prgba_lightness(src[8], src[9], src[10], src[11]) & 0xc0) >> 2) |
1708 (prgba_lightness(src[12], src[13], src[14], src[15]) & 0xc0);
1709 src += 16;
1710 }
1711 if (count <= 0)
1712 return;
1713
1714 v = 0;
1715 for (size_t i=0; i<count; ++i)
1716 {
1717 v |= (prgba_lightness(src[0], src[1], src[2], src[3]) >> 6) << (i*2);
1718 src += 4;
1719 }
1720 *dst = v;
1721 }
1722
1723 static void convert_prgba8888_to_g4(uint8_t *dst, const uint8_t *src, size_t count)
1724 {
1725 for ( ; count >= 2; count -= 2)
1726 {
1727 *(dst++) =
1728 (prgba_lightness(src[0], src[1], src[2], src[3]) >> 4) |
1729 (prgba_lightness(src[4], src[5], src[6], src[7]) & 0xf0);
1730 src += 8;
1731 }
1732 if (count <= 0)
1733 return;
1734
1735 *dst = prgba_lightness(src[0], src[1], src[2], src[3]) >> 4;
1736 }
1737
1738 static void convert_prgba8888_to_g8(uint8_t *dst, const uint8_t *src, size_t count)
1739 {
1740 for ( ; count > 0; --count)
1741 {
1742 *(dst++) = prgba_lightness(src[0], src[1], src[2], src[3]);
1743 src += 4;
1744 }
1745 }
1746
1747 static void convert_prgba8888_to_rgb888(uint8_t *dst, const uint8_t *src, size_t count)
1748 {
1749 uint8_t a;
1750 uint32_t k;
1751 for ( ; count > 0; --count)
1752 {
1753 a = src[3];
1754 if (a != 0)
1755 {
1756 k = 0xfffff / a;
1757 dst[0] = (src[0] * k) >> 12;
1758 dst[1] = (src[1] * k) >> 12;
1759 dst[2] = (src[2] * k) >> 12;
1760 }
1761 else
1762 {
1763 dst[0] = 0;
1764 dst[1] = 0;
1765 dst[2] = 0;
1766 }
1767 src += 4;
1768 dst += 3;
1769 }
1770 }
1771
1772 static void convert_prgba8888_to_bgr888(uint8_t *dst, const uint8_t *src, size_t count)
1773 {
1774 uint8_t a;
1775 uint32_t k;
1776 for ( ; count > 0; --count)
1777 {
1778 a = src[3];
1779 if (a != 0)
1780 {
1781 k = 0xfffff / a;
1782 dst[0] = (src[2] * k) >> 12;
1783 dst[1] = (src[1] * k) >> 12;
1784 dst[2] = (src[0] * k) >> 12;
1785 }
1786 else
1787 {
1788 dst[0] = 0;
1789 dst[1] = 0;
1790 dst[2] = 0;
1791 }
1792 src += 4;
1793 dst += 3;
1794 }
1795 }
1796
1797 static void convert_prgba8888_to_rgba8888(uint8_t *dst, const uint8_t *src, size_t count)
1798 {
1799 uint8_t a;
1800 uint32_t k;
1801 for ( ; count > 0; --count)
1802 {
1803 a = src[3];
1804 if (a != 0)
1805 {
1806 k = 0xfffff / a;
1807 dst[0] = (src[0] * k) >> 12;
1808 dst[1] = (src[1] * k) >> 12;
1809 dst[2] = (src[2] * k) >> 12;
1810 }
1811 else
1812 {
1813 dst[0] = 0;
1814 dst[1] = 0;
1815 dst[2] = 0;
1816 }
1817 dst[3] = a;
1818 src += 4;
1819 dst += 4;
1820 }
1821 }
1822
1823 static void convert_prgba8888_to_bgra8888(uint8_t *dst, const uint8_t *src, size_t count)
1824 {
1825 uint8_t a;
1826 uint32_t k;
1827 for ( ; count > 0; --count)
1828 {
1829 a = src[3];
1830 if (a != 0)
1831 {
1832 k = 0xfffff / a;
1833 dst[0] = (src[2] * k) >> 12;
1834 dst[1] = (src[1] * k) >> 12;
1835 dst[2] = (src[0] * k) >> 12;
1836 }
1837 else
1838 {
1839 dst[0] = 0;
1840 dst[1] = 0;
1841 dst[2] = 0;
1842 }
1843 dst[3] = a;
1844 src += 4;
1845 dst += 4;
1846 }
1847 }
1848
1849 static pixel_conversion_t pixel_convert_function_for_prgba8888(pixel_format_t dst_fmt) noexcept
1850 {
1851 switch (dst_fmt)
1852 {
1853 case PIXFMT_G1:
1854 return convert_prgba8888_to_g1;
1855 case PIXFMT_A1:
1856 return convert_rgba8888_to_a1;
1857 case PIXFMT_G2:
1858 return convert_prgba8888_to_g2;
1859 case PIXFMT_A2:
1860 return convert_rgba8888_to_a2;
1861 case PIXFMT_G4:
1862 return convert_prgba8888_to_g4;
1863 case PIXFMT_A4:
1864 return convert_rgba8888_to_a4;
1865 case PIXFMT_G8:
1866 return convert_prgba8888_to_g8;
1867 case PIXFMT_A8:
1868 return convert_rgba8888_to_a8;
1869 case PIXFMT_RGB888:
1870 return convert_prgba8888_to_rgb888;
1871 case PIXFMT_BGR888:
1872 return convert_prgba8888_to_bgr888;
1873 case PIXFMT_RGBA8888:
1874 return convert_prgba8888_to_rgba8888;
1875 case PIXFMT_BGRA8888:
1876 return convert_prgba8888_to_bgra8888;
1877
1878 default:
1879 break;
1880 }
1881 return NULL;
1882 }
1883
1884
1885 static pixel_conversion_t pixel_convert_function_for_pbgra8888(pixel_format_t dst_fmt) noexcept
1886 {
1887 switch (dst_fmt)
1888 {
1889 case PIXFMT_G1:
1890 return convert_prgba8888_to_g1;
1891 case PIXFMT_A1:
1892 return convert_rgba8888_to_a1;
1893 case PIXFMT_G2:
1894 return convert_prgba8888_to_g2;
1895 case PIXFMT_A2:
1896 return convert_rgba8888_to_a2;
1897 case PIXFMT_G4:
1898 return convert_prgba8888_to_g4;
1899 case PIXFMT_A4:
1900 return convert_rgba8888_to_a4;
1901 case PIXFMT_G8:
1902 return convert_prgba8888_to_g8;
1903 case PIXFMT_A8:
1904 return convert_rgba8888_to_a8;
1905 case PIXFMT_RGB888:
1906 return convert_prgba8888_to_bgr888;
1907 case PIXFMT_BGR888:
1908 return convert_prgba8888_to_rgb888;
1909 case PIXFMT_RGBA8888:
1910 return convert_prgba8888_to_bgra8888;
1911 case PIXFMT_BGRA8888:
1912 return convert_prgba8888_to_rgba8888;
1913
1914 default:
1915 break;
1916 }
1917 return NULL;
1918 }
1919
1920 pixel_conversion_t pixel_convert_function(pixel_format_t dst_fmt, pixel_format_t src_fmt) noexcept
1921 {
1922 switch (src_fmt)
1923 {
1924 case PIXFMT_G1: return pixel_convert_function_for_g1(dst_fmt);
1925 case PIXFMT_A1: return pixel_convert_function_for_a1(dst_fmt);
1926 case PIXFMT_G2: return pixel_convert_function_for_g2(dst_fmt);
1927 case PIXFMT_A2: return pixel_convert_function_for_a2(dst_fmt);
1928 case PIXFMT_G4: return pixel_convert_function_for_g4(dst_fmt);
1929 case PIXFMT_A4: return pixel_convert_function_for_a4(dst_fmt);
1930 case PIXFMT_G8: return pixel_convert_function_for_g8(dst_fmt);
1931 case PIXFMT_A8: return pixel_convert_function_for_a8(dst_fmt);
1932 case PIXFMT_RGB888: return pixel_convert_function_for_rgb888(dst_fmt);
1933 case PIXFMT_BGR888: return pixel_convert_function_for_bgr888(dst_fmt);
1934 case PIXFMT_RGBA8888: return pixel_convert_function_for_rgba8888(dst_fmt);
1935 case PIXFMT_BGRA8888: return pixel_convert_function_for_bgra8888(dst_fmt);
1936 case PIXFMT_PRGBA8888: return pixel_convert_function_for_prgba8888(dst_fmt);
1937 case PIXFMT_PBGRA8888: return pixel_convert_function_for_pbgra8888(dst_fmt);
1938 default:
1939 break;
1940 }
1941
1942 return NULL;
1943 }
1944
1945 void convert_pixels(uint8_t *dst, const uint8_t *src, pixel_format_t dst_fmt, pixel_format_t src_fmt, size_t count) noexcept
1946 {
1947 const pixel_conversion_t func = pixel_convert_function(dst_fmt, src_fmt);
1948 if (func != NULL)
1949 {
1950 func(dst, src, count);
1951 return;
1952 }
1953 if (dst != src)
1954 memcpy(dst, src, device_bits_per_pixel(dst_fmt) * count);
1955 }
1956
1957 } /* namespace mm */
1958 } /* namespace lsp */