212 def unpack_colors(data: bytes, cf: ColorFormat, w) -> List:
220         ret = data
227         for p in data:
238         for p in data:
248         for p in data:
255         pixels = [(data[2 * i + 1] << 8) | data[2 * i]
256                   for i in range(len(data) // 2)]
264             B = data[0::3]
265             G = data[1::3]
266             R = data[2::3]
270             alpha_size = len(data) // 3
271             pixel_alpha = data[-alpha_size:]
272             pixel_data = data[:-alpha_size]
282             L = data[0::3]
283             H = data[1::3]
284             A = data[2::3]
294         B = data[0::4]
295         G = data[1::4]
296         R = data[2::4]
297         A = data[3::4]
313         data: bytes):
364     def write_binary(f, data, stride):  argument
366         for i, v in enumerate(data):
376             write_binary(f, data, 16)
381                 write_binary(f, data[:ncolors * 4], 16)
383             write_binary(f, data[ncolors * 4:], stride)
440     def from_binary(self, data: bytes):
441         if len(data) < 12:
445             self.cf = ColorFormat(data[1] & 0x1f)  # color format
448         self.w = int.from_bytes(data[4:6], 'little')
449         self.h = int.from_bytes(data[6:8], 'little')
450         self.stride = int.from_bytes(data[8:10], 'little')
497                  data: bytes = b'') -> None:
501         self.set_data(cf, w, h, data)
542         def change_stride(data: bytearray, h, current_stride, new_stride):
543             data_in = data
559         data_out = [self.data[:palette_size]]
561             change_stride(self.data[palette_size:], self.h, current.stride,
568             a8_map = self.data[-a8_stride * self.h:]
574         self.data = bytearray(b''.join(data_out))
594             palette = self.data[:palette_size]
600             self.data = palette + self.data[palette_size:]
610                 map = self.data[offset:offset + self.stride]
616                 self.data[offset:offset + line_width] = processed
619             def multiply(data, a):  argument
620                 r = (data >> 11) & 0x1f
621                 g = (data >> 5) & 0x3f
622                 b = (data >> 0) & 0x1f
631                 a = self.data[offset:offset + self.stride // 2]
635                 rgb = self.data[offset:offset + self.stride]
641                 self.data[offset:offset + line_width] = processed
644             def multiply(data, a):  argument
645                 r = (data >> 11) & 0x1f
646                 g = (data >> 5) & 0x3f
647                 b = (data >> 0) & 0x1f
655                 map = self.data[offset:offset + self.stride]
661                 self.data[offset:offset + line_width] = processed
693                  data: bytes,
710         if self.data_len != len(data):
714         self.data = data
718     def from_data(self, data: bytes):
719         header = LVGLImageHeader().from_binary(data)
721                              data[len(header.binary):], header.stride)
732             data = f.read()
733             return self.from_data(data)
766             compressed = LVGLCompressData(self.cf, compress, self.data)
780             data = LVGLCompressData(self.cf, compress, self.data).compressed
782             data = self.data
785                            compress, data)
794             data = self.data
798             palette = [(data[i * 4 + 2], data[i * 4 + 1], data[i * 4 + 0],
799                         data[i * 4 + 3]) for i in range(self.cf.ncolors)]
801             data = data[self.cf.ncolors * 4:]
808             data = unpack_colors(data, self.cf, self.w)
811             transparency = unpack_colors(self.data, self.cf, self.w)
812             data = []
814                 data += [0, 0, 0, a]
823             data = self.data
829             data = unpack_colors(self.data, self.cf, self.w)
835             encoder.write_array(f, data)
1110                  data: bytes = b'') -> None:
1111         super().__init__(cf, w, h, data)
1122         compressed = self.rle_compress(self.data, blksize)
1124             header = RLEHeader(blksize, len(self.data)).binary
1129     def rle_compress(self, data: bytearray, blksize: int, threshold=16):
1131         data_len = len(data)
1133         memview = memoryview(data)
1155     def get_repeat_count(self, data: bytearray, blksize: int):
1156         if len(data) < blksize:
1159         start = data[:blksize]
1164         while index < len(data):
1165             value = data[index:index + blksize]
1177     def get_nonrepeat_count(self, data: bytearray, blksize: int, threshold):
1178         if len(data) < blksize:
1181         pre_value = data[:blksize]
1188             value = data[index:index + blksize]
1203             if index >= len(data):  # data end
1224                  data: bytes = b'') -> None:
1226         self.data = data
1233                            False, CompressMethod.NONE, self.data)
1242             self.data = f.read()