22 def uint8_t(val) -> bytes:
26 def uint16_t(val) -> bytes:
30 def uint24_t(val) -> bytes:
34 def uint32_t(val) -> bytes:
41 def color_pre_multiply(r, g, b, a, background):  argument
46     return ((r * a + (255 - a) * br) >> 8, (g * a + (255 - a) * bg) >> 8,
47             (b * a + (255 - a) * bb) >> 8, a)
74     def __init__(self, ncolors=256, dither=True, exec_path="") -> None:
76         self.cmd = (f"{executable} {'--nofs' if not dither else ''} "
77                     f"{ncolors}  --force - < ")
79     def convert(self, filename) -> bytes:
126     def bpp(self) -> int:
151     def ncolors(self) -> int:
166     def is_indexed(self) -> bool:
173     def is_alpha_only(self) -> bool:
177     def has_alpha(self) -> bool:
185     def is_colormap(self) -> bool:
191     def is_luma_only(self) -> bool:
206         res |= value << (8 - bpp_now)
212 def unpack_colors(data: bytes, cf: ColorFormat, w) -> List:
215     or R,G,B,(A) map
229                 ret.append(values[(p >> (4 - i * 4)) & 0x0f])
240                 ret.append(values[(p >> (6 - i * 2)) & 0x03])
250                 ret.append(values[(p >> (7 - i)) & 0x01])
259             ret.append(bit_extend((p >> 11) & 0x1f, 5))  # R
266             R = data[2::3]
267             for r, g, b in zip(R, G, B):
268                 ret += [r, g, b]
271             pixel_alpha = data[-alpha_size:]
272             pixel_data = data[:-alpha_size]
277                 ret.append(bit_extend((p >> 11) & 0x1f, 5))  # R
288                 ret.append(bit_extend((p >> 11) & 0x1f, 5))  # R
296         R = data[2::4]
298         for r, g, b, a in zip(R, G, B, A):
299             ret += [r, g, b, a]
315     varname = varname.replace("-", "_")
409     def stride_align(self, align: int) -> int:
414             stride = (stride + align - 1) // align
423     def stride_default(self) -> int:
427     def binary(self) -> bytearray:
466     def _compress(self, raw_data: bytes) -> bytearray:
474                 pad = b'\x00' * (self.blk_size - self.raw_data_len % self.blk_size)
497                  data: bytes = b'') -> None:
503     def __repr__(self) -> str:
505                 f"{'Pre-multiplied, ' if self.premultiplied else ''}"
551                 padding = b'\x00' * (new_stride - current_stride)
568             a8_map = self.data[-a8_stride * self.h:]
578         Pre-multiply image RGB data with alpha, set corresponding image header flags
581             raise ParameterError("Image already pre-multiplied")
588             def multiply(r, g, b, a):  argument
589                 r, g, b = (r * a) >> 8, (g * a) >> 8, (b * a) >> 8
590                 return uint8_t(b) + uint8_t(g) + uint8_t(r) + uint8_t(a)
603             def multiply(b, g, r, a):  argument
604                 r, g, b = (r * a) >> 8, (g * a) >> 8, (b * a) >> 8
605                 return uint32_t((a << 24) | (r << 16) | (g << 8) | (b << 0))
620                 r = (data >> 11) & 0x1f
624                 r, g, b = (r * a) // 255, (g * a) // 255, (b * a) // 255
625                 return uint16_t((r << 11) | (g << 5) | (b << 0))
645                 r = (data >> 11) & 0x1f
649                 r, g, b = (r * a) // 255, (g * a) // 255, (b * a) // 255
650                 return uint24_t((a << 16) | (r << 11) | (g << 5) | (b << 0))
668     def data_len(self) -> int:
682     def header(self) -> bytearray:
797             # LVGL palette is in format of B,G,R,A,...
856             for c in names[1:-1]:
909             palette += [(255, 255, 255, 0)] * (cf.ncolors - palette_len)
912         # PNG palette is a list of tuple(R,G,B,A)
915         for (r, g, b, a) in palette:
916             rawdata += uint32_t((a << 24) | (r << 16) | (g << 8) | (b << 0))
941             shift = 8 - cf.bpp
942             mask = 2**cf.bpp - 1
957         return 1.055 * pow(y, 1 / 2.4) - 0.055
964             R = row[0::4]
968             for r, g, b, a in zip(R, G, B, A):
969                 r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
970                 r = self.sRGB_to_linear(r / 255.0)
973                 luma = 0.2126 * r + 0.7152 * g + 0.0722 * b
982             def pack(r, g, b, a):  argument
983                 return uint32_t((a << 24) | (r << 16) | (g << 8) | (b << 0))
986             def pack(r, g, b, a):  argument
987                 r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
988                 return uint32_t((0xff << 24) | (r << 16) | (g << 8) | (b << 0))
991             def pack(r, g, b, a):  argument
992                 r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
993                 return uint24_t((r << 16) | (g << 8) | (b << 0))
996             def pack(r, g, b, a):  argument
997                 r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
998                 color = (r >> 3) << 11
1005             def pack(r, g, b, a):  argument
1006                 color = (r >> 3) << 11
1012             def pack(r, g, b, a):  argument
1013                 color = (r >> 3) << 11
1025             R = row[0::4]
1029             for x, (r, g, b, a) in enumerate(zip(R, G, B, A)):
1039                     r = min(r + red_thresh[treshold_id], 0xFF) & 0xF8
1043                 rawdata += pack(r, g, b, a)
1110                  data: bytes = b'') -> None:
1224                  data: bytes = b'') -> None:
1265                  rgb565_dither=False) -> None:
1315     parser.add_argument('--ofmt',
1320         '--cf',
1330     parser.add_argument('--rgb565dither', action='store_true',
1333     parser.add_argument('--premultiply', action='store_true',
1334                         help="pre-multiply color with alpha", default=False)
1336     parser.add_argument('--compress',
1341     parser.add_argument('--align',
1347     parser.add_argument('--background',
1353     parser.add_argument('-o',
1354                         '--output',
1357     parser.add_argument('-v', '--verbose', action='store_true')
1411     img.to_c_array("output/cogwheel-abc.c")  # file name is used as c var name
1420     img.to_c_array("output/cogwheel-raw.c")