#!/usr/bin/env python3
import os
import logging
import argparse
import subprocess
from os import path
from enum import Enum
from typing import List
from pathlib import Path
try:
import png
except ImportError:
raise ImportError("Need pypng package, do `pip3 install pypng`")
try:
import lz4.block
except ImportError:
raise ImportError("Need lz4 package, do `pip3 install lz4`")
def uint8_t(val) -> bytes:
return val.to_bytes(1, byteorder='little')
def uint16_t(val) -> bytes:
return val.to_bytes(2, byteorder='little')
def uint24_t(val) -> bytes:
return val.to_bytes(3, byteorder='little')
def uint32_t(val) -> bytes:
try:
return val.to_bytes(4, byteorder='little')
except OverflowError:
raise ParameterError(f"overflow: {hex(val)}")
def color_pre_multiply(r, g, b, a, background):
bb = background & 0xff
bg = (background >> 8) & 0xff
br = (background >> 16) & 0xff
return ((r * a + (255 - a) * br) >> 8, (g * a + (255 - a) * bg) >> 8,
(b * a + (255 - a) * bb) >> 8, a)
class Error(Exception):
def __str__(self):
return self.__class__.__name__ + ': ' + ' '.join(self.args)
class FormatError(Error):
"""
Problem with input filename format.
BIN filename does not conform to standard lvgl bin image format
"""
class ParameterError(Error):
"""
Parameter for LVGL image not correct
"""
class PngQuant:
"""
Compress PNG file to 8bit mode using `pngquant`
"""
def __init__(self, ncolors=256, dither=True, exec_path="") -> None:
executable = path.join(exec_path, "pngquant")
self.cmd = (f"{executable} {'--nofs' if not dither else ''} "
f"{ncolors} --force - < ")
def convert(self, filename) -> bytes:
if not os.path.isfile(filename):
raise BaseException(f"file not found: {filename}")
try:
compressed = subprocess.check_output(
f'{self.cmd} "{str(filename)}"',
stderr=subprocess.STDOUT,
shell=True)
except subprocess.CalledProcessError:
raise BaseException(
"cannot find pngquant tool, install it via "
"`sudo apt install pngquant` for debian "
"or `brew install pngquant` for macintosh "
"For windows, you may need to download pngquant.exe from "
"https://pngquant.org/, and put it in your PATH.")
return compressed
class CompressMethod(Enum):
NONE = 0x00
RLE = 0x01
LZ4 = 0x02
class ColorFormat(Enum):
UNKNOWN = 0x00
L8 = 0x06
I1 = 0x07
I2 = 0x08
I4 = 0x09
I8 = 0x0A
A1 = 0x0B
A2 = 0x0C
A4 = 0x0D
A8 = 0x0E
ARGB8888 = 0x10
XRGB8888 = 0x11
RGB565 = 0x12
ARGB8565 = 0x13
RGB565A8 = 0x14
RGB888 = 0x0F
@property
def bpp(self) -> int:
"""
Return bit per pixel for this cf
"""
cf_map = {
ColorFormat.UNKNOWN: 0x00,
ColorFormat.L8: 8,
ColorFormat.I1: 1,
ColorFormat.I2: 2,
ColorFormat.I4: 4,
ColorFormat.I8: 8,
ColorFormat.A1: 1,
ColorFormat.A2: 2,
ColorFormat.A4: 4,
ColorFormat.A8: 8,
ColorFormat.ARGB8888: 32,
ColorFormat.XRGB8888: 32,
ColorFormat.RGB565: 16,
ColorFormat.RGB565A8: 16, # 16bpp + a8 map
ColorFormat.ARGB8565: 24,
ColorFormat.RGB888: 24,
}
return cf_map[self]
@property
def ncolors(self) -> int:
"""
Return number of colors in palette if cf is indexed1/2/4/8.
Return zero if cf is not indexed format
"""
cf_map = {
ColorFormat.I1: 2,
ColorFormat.I2: 4,
ColorFormat.I4: 16,
ColorFormat.I8: 256,
}
return cf_map.get(self, 0)
@property
def is_indexed(self) -> bool:
"""
Return if cf is indexed color format
"""
return self.ncolors != 0
@property
def is_alpha_only(self) -> bool:
return ColorFormat.A1.value <= self.value <= ColorFormat.A8.value
@property
def has_alpha(self) -> bool:
return self.is_alpha_only or self in (
ColorFormat.ARGB8888,
ColorFormat.XRGB8888, # const alpha: 0xff
ColorFormat.ARGB8565,
ColorFormat.RGB565A8)
@property
def is_colormap(self) -> bool:
return self in (ColorFormat.ARGB8888, ColorFormat.RGB888,
ColorFormat.XRGB8888, ColorFormat.RGB565A8,
ColorFormat.ARGB8565, ColorFormat.RGB565)
@property
def is_luma_only(self) -> bool:
return self in (ColorFormat.L8, )
def bit_extend(value, bpp):
"""
Extend value from bpp to 8 bit with interpolation to reduce rounding error.
"""
if value == 0:
return 0
res = value
bpp_now = bpp
while bpp_now < 8:
res |= value << (8 - bpp_now)
bpp_now += bpp
return res
def unpack_colors(data: bytes, cf: ColorFormat, w) -> List:
"""
Unpack lvgl 1/2/4/8/16/32 bpp color to png color: alpha map, grey scale,
or R,G,B,(A) map
"""
ret = []
bpp = cf.bpp
if bpp == 8:
ret = data
elif bpp == 4:
if cf == ColorFormat.A4:
values = [x * 17 for x in range(16)]
else:
values = [x for x in range(16)]
for p in data:
for i in range(2):
ret.append(values[(p >> (4 - i * 4)) & 0x0f])
if len(ret) % w == 0:
break
elif bpp == 2:
if cf == ColorFormat.A2:
values = [x * 85 for x in range(4)]
else: # must be ColorFormat.I2
values = [x for x in range(4)]
for p in data:
for i in range(4):
ret.append(values[(p >> (6 - i * 2)) & 0x03])
if len(ret) % w == 0:
break
elif bpp == 1:
if cf == ColorFormat.A1:
values = [0, 255]
else:
values = [0, 1]
for p in data:
for i in range(8):
ret.append(values[(p >> (7 - i)) & 0x01])
if len(ret) % w == 0:
break
elif bpp == 16:
# This is RGB565
pixels = [(data[2 * i + 1] << 8) | data[2 * i]
for i in range(len(data) // 2)]
for p in pixels:
ret.append(bit_extend((p >> 11) & 0x1f, 5)) # R
ret.append(bit_extend((p >> 5) & 0x3f, 6)) # G
ret.append(bit_extend((p >> 0) & 0x1f, 5)) # B
elif bpp == 24:
if cf == ColorFormat.RGB888:
B = data[0::3]
G = data[1::3]
R = data[2::3]
for r, g, b in zip(R, G, B):
ret += [r, g, b]
elif cf == ColorFormat.RGB565A8:
alpha_size = len(data) // 3
pixel_alpha = data[-alpha_size:]
pixel_data = data[:-alpha_size]
pixels = [(pixel_data[2 * i + 1] << 8) | pixel_data[2 * i]
for i in range(len(pixel_data) // 2)]
for a, p in zip(pixel_alpha, pixels):
ret.append(bit_extend((p >> 11) & 0x1f, 5)) # R
ret.append(bit_extend((p >> 5) & 0x3f, 6)) # G
ret.append(bit_extend((p >> 0) & 0x1f, 5)) # B
ret.append(a)
elif cf == ColorFormat.ARGB8565:
L = data[0::3]
H = data[1::3]
A = data[2::3]
for h, l, a in zip(H, L, A):
p = (h << 8) | (l)
ret.append(bit_extend((p >> 11) & 0x1f, 5)) # R
ret.append(bit_extend((p >> 5) & 0x3f, 6)) # G
ret.append(bit_extend((p >> 0) & 0x1f, 5)) # B
ret.append(a) # A
elif bpp == 32:
B = data[0::4]
G = data[1::4]
R = data[2::4]
A = data[3::4]
for r, g, b, a in zip(R, G, B, A):
ret += [r, g, b, a]
else:
assert 0
return ret
class LVGLImageHeader:
def __init__(self,
cf: ColorFormat = ColorFormat.UNKNOWN,
w: int = 0,
h: int = 0,
stride: int = 0,
align: int = 1,
flags: int = 0):
self.cf = cf
self.flags = flags
self.w = w & 0xffff
self.h = h & 0xffff
if w > 0xffff or h > 0xffff:
raise ParameterError(f"w, h overflow: {w}x{h}")
if align < 1:
# stride align in bytes must be larger than 1
raise ParameterError(f"Invalid stride align: {align}")
self.stride = self.stride_align(align) if stride == 0 else stride
def stride_align(self, align: int) -> int:
stride = self.stride_default
if align == 1:
pass
elif align > 1:
stride = (stride + align - 1) // align
stride *= align
else:
raise ParameterError(f"Invalid stride align: {align}")
self.stride = stride
return stride
@property
def stride_default(self) -> int:
return (self.w * self.cf.bpp + 7) // 8
@property
def binary(self) -> bytearray:
binary = bytearray()
binary += uint8_t(0x19) # magic number for lvgl version 9
binary += uint8_t(self.cf.value)
binary += uint16_t(self.flags) # 16bits flags
binary += uint16_t(self.w) # 16bits width
binary += uint16_t(self.h) # 16bits height
binary += uint16_t(self.stride) # 16bits stride
binary += uint16_t(0) # 16bits reserved
return binary
def from_binary(self, data: bytes):
if len(data) < 12:
raise FormatError("invalid header length")
try:
self.cf = ColorFormat(data[1] & 0x1f) # color format
except ValueError as exc:
raise FormatError(f"invalid color format: {hex(data[0])}") from exc
self.w = int.from_bytes(data[4:6], 'little')
self.h = int.from_bytes(data[6:8], 'little')
self.stride = int.from_bytes(data[8:10], 'little')
return self
class LVGLCompressData:
def __init__(self,
cf: ColorFormat,
method: CompressMethod,
raw_data: bytes = b''):
self.blk_size = (cf.bpp + 7) // 8
self.compress = method
self.raw_data = raw_data
self.raw_data_len = len(raw_data)
self.compressed = self._compress(raw_data)
def _compress(self, raw_data: bytes) -> bytearray:
if self.compress == CompressMethod.NONE:
return raw_data
if self.compress == CompressMethod.RLE:
# RLE compression performs on pixel unit, pad data to pixel unit
pad = b'\x00' * (self.blk_size - self.raw_data_len % self.blk_size)
self.raw_data_len += len(pad)
compressed = RLEImage().rle_compress(raw_data + pad, self.blk_size)
elif self.compress == CompressMethod.LZ4:
compressed = lz4.block.compress(raw_data, store_size=False)
else:
raise ParameterError(f"Invalid compress method: {self.compress}")
self.compressed_len = len(compressed)
bin = bytearray()
bin += uint32_t(self.compress.value)
bin += uint32_t(self.compressed_len)
bin += uint32_t(self.raw_data_len)
bin += compressed
return bin
class LVGLImage:
def __init__(self,
cf: ColorFormat = ColorFormat.UNKNOWN,
w: int = 0,
h: int = 0,
data: bytes = b'') -> None:
self.stride = 0 # default no valid stride value
self.set_data(cf, w, h, data)
def __repr__(self) -> str:
return (
f"'LVGL image {self.w}x{self.h}, {self.cf.name}, stride: {self.stride}"
f" (12+{self.data_len})Byte'")
def adjust_stride(self, stride: int = 0, align: int = 1):
"""
Stride can be set directly, or by stride alignment in bytes
"""
if self.stride == 0:
# stride can only be 0, when LVGLImage is created with empty data
logging.warning("Cannot adjust stride for empty image")
return
if align >= 1 and stride == 0:
# The header with specified stride alignment
header = LVGLImageHeader(self.cf, self.w, self.h, align=align)
stride = header.stride
elif stride > 0:
pass
else:
raise ParameterError(f"Invalid parameter, align:{align},"
f" stride:{stride}")
if self.stride == stride:
return # no stride adjustment
# if current image is empty, no need to do anything
if self.data_len == 0:
self.stride = 0
return
current = LVGLImageHeader(self.cf, self.w, self.h, stride=self.stride)
if stride < current.stride_default:
raise ParameterError(f"Stride is too small:{stride}, "
f"minimal:{current.stride_default}")
def change_stride(data: bytearray, h, current_stride, new_stride):
data_in = data
data_out = [] # stride adjusted new data
if new_stride < current_stride: # remove padding byte
for i in range(h):
start = i * current_stride
end = start + new_stride
data_out.append(data_in[start:end])
else: # adding more padding bytes
padding = b'\x00' * (new_stride - current_stride)
for i in range(h):
data_out.append(data_in[i * current_stride:(i + 1) *
current_stride])
data_out.append(padding)
return b''.join(data_out)
palette_size = self.cf.ncolors * 4
data_out = [self.data[:palette_size]]
data_out.append(
change_stride(self.data[palette_size:], self.h, current.stride,
stride))
# deal with alpha map for RGB565A8
if self.cf == ColorFormat.RGB565A8:
logging.warning("handle RGB565A8 alpha map")
a8_stride = self.stride // 2
a8_map = self.data[-a8_stride * self.h:]
data_out.append(
change_stride(a8_map, self.h, current.stride // 2,
stride // 2))
self.stride = stride
self.data = b''.join(data_out)
@property
def data_len(self) -> int:
"""
Return data_len in byte of this image, excluding image header
"""
# palette is always in ARGB format, 4Byte per color
p = self.cf.ncolors * 4 if self.is_indexed and self.w * self.h else 0
p += self.stride * self.h
if self.cf is ColorFormat.RGB565A8:
a8_stride = self.stride // 2
p += a8_stride * self.h
return p
@property
def header(self) -> bytearray:
return LVGLImageHeader(self.cf, self.w, self.h)
@property
def is_indexed(self):
return self.cf.is_indexed
def set_data(self,
cf: ColorFormat,
w: int,
h: int,
data: bytes,
stride: int = 0):
"""
Directly set LVGL image parameters
"""
if w > 0xffff or h > 0xffff:
raise ParameterError(f"w, h overflow: {w}x{h}")
self.cf = cf
self.w = w
self.h = h
# if stride is 0, then it's aligned to 1byte by default,
# let image header handle it
self.stride = LVGLImageHeader(cf, w, h, stride, align=1).stride
if self.data_len != len(data):
raise ParameterError(f"{self} data length error got: {len(data)}, "
f"expect: {self.data_len}, {self}")
self.data = data
return self
def from_data(self, data: bytes):
header = LVGLImageHeader().from_binary(data)
return self.set_data(header.cf, header.w, header.h,
data[len(header.binary):], header.stride)
def from_bin(self, filename: str):
"""
Read from existing bin file and update image parameters
"""
if not filename.endswith(".bin"):
raise FormatError("filename not ended with '.bin'")
with open(filename, "rb") as f:
data = f.read()
return self.from_data(data)
def _check_ext(self, filename: str, ext):
if not filename.lower().endswith(ext):
raise FormatError(f"filename not ended with {ext}")
def _check_dir(self, filename: str):
dir = path.dirname(filename)
if dir and not path.exists(dir):
logging.info(f"mkdir of {dir} for {filename}")
os.makedirs(dir)
def to_bin(self,
filename: str,
compress: CompressMethod = CompressMethod.NONE):
"""
Write this image to file, filename should be ended with '.bin'
"""
self._check_ext(filename, ".bin")
self._check_dir(filename)
with open(filename, "wb+") as f:
bin = bytearray()
flags = 0
flags |= 0x08 if compress != CompressMethod.NONE else 0
header = LVGLImageHeader(self.cf,
self.w,
self.h,
self.stride,
flags=flags)
bin += header.binary
compressed = LVGLCompressData(self.cf, compress, self.data)
bin += compressed.compressed
f.write(bin)
return self
def to_c_array(self,
filename: str,
compress: CompressMethod = CompressMethod.NONE):
self._check_ext(filename, ".c")
self._check_dir(filename)
varname = path.basename(filename).split('.')[0]
varname = varname.replace("-", "_")
varname = varname.replace(".", "_")
flags = "0"
if compress is not CompressMethod.NONE:
flags += " | LV_IMAGE_FLAGS_COMPRESSED"
compressed = LVGLCompressData(self.cf, compress, self.data)
header = f'''
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#elif defined(LV_BUILD_TEST)
#include "../lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_DUST
#define LV_ATTRIBUTE_IMG_DUST
#endif
static const
LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_DUST
uint8_t {varname}_map[] = {{
'''
ending = f'''
}};
const lv_image_dsc_t {varname} = {{
.header.magic = LV_IMAGE_HEADER_MAGIC,
.header.cf = LV_COLOR_FORMAT_{self.cf.name},
.header.flags = {flags},
.header.w = {self.w},
.header.h = {self.h},
.header.stride = {self.stride},
.data_size = sizeof({varname}_map),
.data = {varname}_map,
}};
'''
def write_binary(f, data, stride):
for i, v in enumerate(data):
if i % stride == 0:
f.write("\n ")
f.write(f"0x{v:02x},")
f.write("\n")
with open(filename, "w+") as f:
f.write(header)
if compress is not CompressMethod.NONE:
write_binary(f, compressed.compressed, 16)
else:
# write palette separately
ncolors = self.cf.ncolors
if ncolors:
write_binary(f, self.data[:ncolors * 4], 16)
write_binary(f, self.data[ncolors * 4:], self.stride)
f.write(ending)
return self
def to_png(self, filename: str):
self._check_ext(filename, ".png")
self._check_dir(filename)
old_stride = self.stride
self.adjust_stride(align=1)
if self.cf.is_indexed:
data = self.data
# Separate lvgl bin image data to palette and bitmap
# The palette is in format of [(RGBA), (RGBA)...].
# LVGL palette is in format of B,G,R,A,...
palette = [(data[i * 4 + 2], data[i * 4 + 1], data[i * 4 + 0],
data[i * 4 + 3]) for i in range(self.cf.ncolors)]
data = data[self.cf.ncolors * 4:]
encoder = png.Writer(self.w,
self.h,
palette=palette,
bitdepth=self.cf.bpp)
# separate packed data to plain data
data = unpack_colors(data, self.cf, self.w)
elif self.cf.is_alpha_only:
# separate packed data to plain data
transparency = unpack_colors(self.data, self.cf, self.w)
data = []
for a in transparency:
data += [0, 0, 0, a]
encoder = png.Writer(self.w, self.h, greyscale=False, alpha=True)
elif self.cf == ColorFormat.L8:
# to grayscale
encoder = png.Writer(self.w,
self.h,
bitdepth=self.cf.bpp,
greyscale=True,
alpha=False)
data = self.data
elif self.cf.is_colormap:
encoder = png.Writer(self.w,
self.h,
alpha=self.cf.has_alpha,
greyscale=False)
data = unpack_colors(self.data, self.cf, self.w)
else:
logging.warning(f"missing logic: {self.cf.name}")
return
with open(filename, "wb") as f:
encoder.write_array(f, data)
self.adjust_stride(stride=old_stride)
def from_png(self,
filename: str,
cf: ColorFormat = None,
background: int = 0x00_00_00):
"""
Create lvgl image from png file.
If cf is none, used I1/2/4/8 based on palette size
"""
self.background = background
if cf is None: # guess cf from filename
# split filename string and match with ColorFormat to check
# which cf to use
names = str(path.basename(filename)).split(".")
for c in names[1:-1]:
if c in ColorFormat.__members__:
cf = ColorFormat[c]
break
if cf is None or cf.is_indexed: # palette mode
self._png_to_indexed(cf, filename)
elif cf.is_alpha_only:
self._png_to_alpha_only(cf, filename)
elif cf.is_luma_only:
self._png_to_luma_only(cf, filename)
elif cf.is_colormap:
self._png_to_colormap(cf, filename)
else:
logging.warning(f"missing logic: {cf.name}")
logging.info(f"from png: {filename}, cf: {self.cf.name}")
return self
def _png_to_indexed(self, cf: ColorFormat, filename: str):
# convert to palette mode
auto_cf = cf is None
reader = png.Reader(
bytes=PngQuant(256 if auto_cf else cf.ncolors).convert(filename))
w, h, rows, _ = reader.read()
palette = reader.palette(alpha="force") # always return alpha
palette_len = len(palette)
if auto_cf:
if palette_len <= 2:
cf = ColorFormat.I1
elif palette_len <= 4:
cf = ColorFormat.I2
elif palette_len <= 16:
cf = ColorFormat.I4
else:
cf = ColorFormat.I8
if palette_len != cf.ncolors:
if not auto_cf:
logging.warning(
f"{path.basename(filename)} palette: {palette_len}, "
f"extended to: {cf.ncolors}")
palette += [(255, 255, 255, 0)] * (cf.ncolors - palette_len)
# Assemble lvgl image palette from PNG palette.
# PNG palette is a list of tuple(R,G,B,A)
rawdata = bytearray()
for (r, g, b, a) in palette:
rawdata += uint32_t((a << 24) | (r << 16) | (g << 8) | (b << 0))
# pack data if not in I8 format
if cf == ColorFormat.I8:
for e in rows:
rawdata += e
else:
for e in png.pack_rows(rows, cf.bpp):
rawdata += e
self.set_data(cf, w, h, rawdata)
def _png_to_alpha_only(self, cf: ColorFormat, filename: str):
reader = png.Reader(str(filename))
w, h, rows, info = reader.asRGBA8()
if not info['alpha']:
raise FormatError(f"{filename} has no alpha channel")
rawdata = bytearray()
if cf == ColorFormat.A8:
for row in rows:
A = row[3::4]
for e in A:
rawdata += uint8_t(e)
else:
shift = 8 - cf.bpp
mask = 2**cf.bpp - 1
rows = [[(a >> shift) & mask for a in row[3::4]] for row in rows]
for row in png.pack_rows(rows, cf.bpp):
rawdata += row
self.set_data(cf, w, h, rawdata)
def _png_to_luma_only(self, cf: ColorFormat, filename: str):
reader = png.Reader(str(filename))
w, h, rows, info = reader.asRGBA8()
rawdata = bytearray()
for row in rows:
R = row[0::4]
G = row[1::4]
B = row[2::4]
A = row[3::4]
for r, g, b, a in zip(R, G, B, A):
r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
luma = 0.2126 * r + 0.7152 * g + 0.0722 * b
rawdata += uint8_t(int(luma))
self.set_data(ColorFormat.L8, w, h, rawdata)
def _png_to_colormap(self, cf, filename: str):
if cf == ColorFormat.ARGB8888:
def pack(r, g, b, a):
return uint32_t((a << 24) | (r << 16) | (g << 8) | (b << 0))
elif cf == ColorFormat.XRGB8888:
def pack(r, g, b, a):
r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
return uint32_t((0xff << 24) | (r << 16) | (g << 8) | (b << 0))
elif cf == ColorFormat.RGB888:
def pack(r, g, b, a):
r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
return uint24_t((r << 16) | (g << 8) | (b << 0))
elif cf == ColorFormat.RGB565:
def pack(r, g, b, a):
r, g, b, a = color_pre_multiply(r, g, b, a, self.background)
color = (r >> 3) << 11
color |= (g >> 2) << 5
color |= (b >> 3) << 0
return uint16_t(color)
elif cf == ColorFormat.RGB565A8:
def pack(r, g, b, a):
color = (r >> 3) << 11
color |= (g >> 2) << 5
color |= (b >> 3) << 0
return uint16_t(color)
elif cf == ColorFormat.ARGB8565:
def pack(r, g, b, a):
color = (r >> 3) << 11
color |= (g >> 2) << 5
color |= (b >> 3) << 0
return uint24_t((a << 16) | color)
else:
raise FormatError(f"Invalid color format: {cf.name}")
reader = png.Reader(str(filename))
w, h, rows, _ = reader.asRGBA8()
rawdata = bytearray()
alpha = bytearray()
for row in rows:
R = row[0::4]
G = row[1::4]
B = row[2::4]
A = row[3::4]
for r, g, b, a in zip(R, G, B, A):
if cf == ColorFormat.RGB565A8:
alpha += uint8_t(a)
rawdata += pack(r, g, b, a)
if cf == ColorFormat.RGB565A8:
rawdata += alpha
self.set_data(cf, w, h, rawdata)
class RLEHeader:
def __init__(self, blksize: int, len: int):
self.blksize = blksize
self.len = len
@property
def binary(self):
magic = 0x5aa521e0
rle_header = self.blksize
rle_header |= (self.len & 0xffffff) << 4
binary = bytearray()
binary.extend(uint32_t(magic))
binary.extend(uint32_t(rle_header))
return binary
class RLEImage(LVGLImage):
def __init__(self,
cf: ColorFormat = ColorFormat.UNKNOWN,
w: int = 0,
h: int = 0,
data: bytes = b'') -> None:
super().__init__(cf, w, h, data)
def to_rle(self, filename: str):
"""
Compress this image to file, filename should be ended with '.rle'
"""
self._check_ext(filename, ".rle")
self._check_dir(filename)
# compress image data excluding lvgl image header
blksize = (self.cf.bpp + 7) // 8
compressed = self.rle_compress(self.data, blksize)
with open(filename, "wb+") as f:
header = RLEHeader(blksize, len(self.data)).binary
header.extend(self.header.binary)
f.write(header)
f.write(compressed)
def rle_compress(self, data: bytearray, blksize: int, threshold=16):
index = 0
data_len = len(data)
compressed_data = []
memview = memoryview(data)
while index < data_len:
repeat_cnt = self.get_repeat_count(memview[index:], blksize)
if repeat_cnt == 0:
# done
break
elif repeat_cnt < threshold:
nonrepeat_cnt = self.get_nonrepeat_count(
memview[index:], blksize, threshold)
ctrl_byte = uint8_t(nonrepeat_cnt | 0x80)
compressed_data.append(ctrl_byte)
compressed_data.append(memview[index:index +
nonrepeat_cnt * blksize])
index += nonrepeat_cnt * blksize
else:
ctrl_byte = uint8_t(repeat_cnt)
compressed_data.append(ctrl_byte)
compressed_data.append(memview[index:index + blksize])
index += repeat_cnt * blksize
return b"".join(compressed_data)
def get_repeat_count(self, data: bytearray, blksize: int):
if len(data) < blksize:
return 0
start = data[:blksize]
index = 0
repeat_cnt = 0
value = 0
while index < len(data):
value = data[index:index + blksize]
if value == start:
repeat_cnt += 1
if repeat_cnt == 127: # limit max repeat count to max value of signed char.
break
else:
break
index += blksize
return repeat_cnt
def get_nonrepeat_count(self, data: bytearray, blksize: int, threshold):
if len(data) < blksize:
return 0
pre_value = data[:blksize]
index = 0
nonrepeat_count = 0
repeat_cnt = 0
while True:
value = data[index:index + blksize]
if value == pre_value:
repeat_cnt += 1
if repeat_cnt > threshold:
# repeat found.
break
else:
pre_value = value
nonrepeat_count += 1 + repeat_cnt
repeat_cnt = 0
if nonrepeat_count >= 127: # limit max repeat count to max value of signed char.
nonrepeat_count = 127
break
index += blksize # move to next position
if index >= len(data): # data end
nonrepeat_count += repeat_cnt
break
return nonrepeat_count
class OutputFormat(Enum):
C_ARRAY = "C"
BIN_FILE = "BIN"
RAW_DATA = "RAW" # option of not writing any file
PNG_FILE = "PNG" # convert to lvgl image and then to png
class PNGConverter:
def __init__(self,
files: List,
cf: ColorFormat,
ofmt: OutputFormat,
odir: str,
background: int = 0x00,
align: int = 1,
compress: CompressMethod = CompressMethod.NONE,
keep_folder=True) -> None:
self.files = files
self.cf = cf
self.ofmt = ofmt
self.output = odir
self.pngquant = None
self.keep_folder = keep_folder
self.align = align
self.compress = compress
self.background = background
def _replace_ext(self, input, ext):
if self.keep_folder:
name, _ = path.splitext(input)
else:
name, _ = path.splitext(path.basename(input))
output = name + ext
output = path.join(self.output, output)
return output
def convert(self):
output = []
for f in self.files:
img = LVGLImage().from_png(f, self.cf, background=self.background)
img.adjust_stride(align=self.align)
output.append((f, img))
if self.ofmt == OutputFormat.BIN_FILE:
img.to_bin(self._replace_ext(f, ".bin"),
compress=self.compress)
elif self.ofmt == OutputFormat.C_ARRAY:
img.to_c_array(self._replace_ext(f, ".c"),
compress=self.compress)
elif self.ofmt == OutputFormat.PNG_FILE:
img.to_png(self._replace_ext(f, ".png"))
return output
def main():
parser = argparse.ArgumentParser(description='LVGL PNG to bin image tool.')
parser.add_argument('--ofmt',
help="output filename format, C or BIN",
default="BIN",
choices=["C", "BIN", "PNG"])
parser.add_argument(
'--cf',
help=("bin image color format, use AUTO for automatically "
"choose from I1/2/4/8"),
default="I8",
choices=[
"L8", "I1", "I2", "I4", "I8", "A1", "A2", "A4", "A8", "ARGB8888",
"XRGB8888", "RGB565", "RGB565A8", "ARGB8565", "RGB888", "AUTO"
])
parser.add_argument('--compress',
help=("Binary data compress method, default to NONE"),
default="NONE",
choices=["NONE", "RLE", "LZ4"])
parser.add_argument('--align',
help="stride alignment in bytes for bin image",
default=1,
type=int,
metavar='byte',
nargs='?')
parser.add_argument('--background',
help="Background color for formats without alpha",
default=0x00_00_00,
type=lambda x: int(x, 0),
metavar='color',
nargs='?')
parser.add_argument('-o',
'--output',
default="./output",
help="Select the output folder, default to ./output")
parser.add_argument('-v', '--verbose', action='store_true')
parser.add_argument(
'input', help="the filename or folder to be recursively converted")
args = parser.parse_args()
if path.isfile(args.input):
files = [args.input]
elif path.isdir(args.input):
files = list(Path(args.input).rglob("*.[pP][nN][gG]"))
else:
raise BaseException(f"invalid input: {args.input}")
if args.verbose:
logging.basicConfig(level=logging.INFO)
logging.info(f"options: {args.__dict__}, files:{[str(f) for f in files]}")
if args.cf == "AUTO":
cf = None
else:
cf = ColorFormat[args.cf]
ofmt = OutputFormat(args.ofmt)
compress = CompressMethod[args.compress]
converter = PNGConverter(files,
cf,
ofmt,
args.output,
background=args.background,
align=args.align,
compress=compress,
keep_folder=False)
output = converter.convert()
for f, img in output:
logging.info(f"len: {img.data_len} for {path.basename(f)} ")
print(f"done {len(files)} files")
def test():
logging.basicConfig(level=logging.INFO)
f = "pngs/cogwheel.RGB565A8.png"
img = LVGLImage().from_png(f,
cf=ColorFormat.ARGB8565,
background=0xFF_FF_00)
img.adjust_stride(align=16)
img.to_bin("output/cogwheel.ARGB8565.bin")
img.to_c_array("output/cogwheel-abc.c") # file name is used as c var name
img.to_png("output/cogwheel.ARGB8565.png.png") # convert back to png
if __name__ == "__main__":
# test()
main()