qgif 0.1.0__tar.gz

qgif-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: qgif
+Version: 0.1.0
+Summary: Convert GIF to QGIF, or decode QGIF.
+Author: Hangzhou Nationalchip Inc.
+Author-email: zhengdi@nationalchip.com
+License: MIT Licence
+Keywords: qgif nationalchip
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3

qgif-0.1.0/qgif/__init__.py

@@ -0,0 +1 @@
+VERSION = "0.1.0"

qgif-0.1.0/qgif/__main__.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import argparse
+
+from qgif import VERSION
+from qgif.qgif import convert_gif_to_qgif, decode_qgif
+
+def check_range(param_name, t):
+    def checker(value):
+        value = t(value)
+        if value < 0 or value > 10:
+            raise argparse.ArgumentTypeError(f"Argument '{param_name}' must be between 0 and 10, but got {value}")
+        return value
+    return checker
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(prog="qgif", description="QGIF generator and decoder")
+    subparsers = parser.add_subparsers(dest="command")
+
+    parser_convert = subparsers.add_parser("convert", help="Convert GIF to QGIF.")
+    parser_convert.add_argument("-f", "--format", required=True, choices=["gx64", "gx96"], help="The format of generated QGIF frames.")
+    parser_convert.add_argument("-i", "--input", required=True, help="The input GIF file name.")
+    parser_convert.add_argument("-o", "--output", required=True, help="Generated QGIF file name.")
+    parser_convert.add_argument("-fr", "--framerate", type=int, default=0, help="The frame rate of QGIF file. (default: same as GIF)")
+    parser_convert.add_argument("-l", "--lvgl", action="store_true", help="Generate LVGL C file.")
+    parser_convert.add_argument("--crop-size", type=int, nargs=2, help="Size to crop the image (width height)")
+    parser_convert.add_argument("--scale-size", type=int, nargs=2, help="Size to scale the image (width height)")
+    parser_convert.add_argument("--bilateral-strength", default=0, type=check_range("--bilateral-strength", float),
+            help="Strength of bilateral filter (0-10, can be a float)")
+    parser_convert.add_argument("--median-strength", default=0, type=check_range("--median-strength", int),
+            help="Strength of spatial median filter (0-10)")
+    parser_convert.add_argument("--interframe-threshold", default=0, type=check_range("--interframe-threshold", int),
+            help="Threshold for interframe median filtering (0-10)")
+    parser_convert.add_argument("--temporal-threshold", default=0, type=check_range("--temporal-threshold", int),
+            help="Threshold for temporal denoise (0-10)")
+
+    parser_decode = subparsers.add_parser("decode", help="Decode QGIF to frames.")
+    parser_decode.add_argument("-i", "--input", required=True, help="The input QGIF file name.")
+    parser_decode.add_argument("-o", "--output", required=True, help="The directory of output frames and pngs.")
+    parser_decode.add_argument("-c", "--colordepth", type=int, required=True, choices=[16, 32], help="The color depth of decoded frames.")
+
+    parser.add_argument("-V", "--version", action="version", version="qgif %s" % VERSION)
+
+    args = parser.parse_args()
+    if args.command == "convert":
+        convert_gif_to_qgif(args.input,
+                args.output,
+                args.format,
+                args.lvgl,
+                args.framerate,
+                crop_size=args.crop_size,
+                scale_size=args.scale_size,
+                bilateral_strength=args.bilateral_strength,
+                median_strength=args.median_strength,
+                interframe_threshold=args.interframe_threshold,
+                temporal_threshold=args.temporal_threshold)
+    elif args.command == "decode":
+        decode_qgif(args.input, args.output, args.colordepth)
+

qgif-0.1.0/qgif/gen_lvgl_file.py

@@ -0,0 +1,84 @@
+import os
+import re
+
+def sanitize_filename(filename):
+    # 移除不合法的字符，只保留字母、数字和下划线
+    sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', filename)
+
+    # 如果第一个字符是数字，则在前面加上一个下划线
+    if sanitized and sanitized[0].isdigit():
+        sanitized = '_' + sanitized
+
+    # 检查是否是C语言的关键字
+    c_keywords = {
+        "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern",
+        "float", "for", "goto", "if", "inline", "int", "long", "register", "restrict", "return", "short", "signed",
+        "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while", "_Alignas",
+        "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary", "_Noreturn", "_Static_assert", "_Thread_local"
+    }
+
+    if sanitized in c_keywords:
+        sanitized = '_' + sanitized
+
+    return sanitized
+
+def gen_lvgl_file(bin_file, lvgl_file, image_width, image_height):
+    image_name_with_extension = os.path.basename(bin_file)
+    image_name, _ = os.path.splitext(image_name_with_extension)
+    image_name = sanitize_filename(image_name)
+
+    # 读取二进制文件
+    with open(bin_file, 'rb') as bin_file:
+        bin_data = bin_file.read()
+
+    # 生成C文件内容
+    c_file_content = f"""#ifdef __has_include
+    #if __has_include("lvgl.h")
+        #ifndef LV_LVGL_H_INCLUDE_SIMPLE
+            #define LV_LVGL_H_INCLUDE_SIMPLE
+        #endif
+    #endif
+#endif
+
+#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
+    #include "lvgl.h"
+#else
+    #include "lvgl/lvgl.h"
+#endif
+
+#ifndef LV_ATTRIBUTE_MEM_ALIGN
+#define LV_ATTRIBUTE_MEM_ALIGN
+#endif
+
+#ifndef LV_ATTRIBUTE_IMG_{image_name.upper()}
+#define LV_ATTRIBUTE_IMG_{image_name.upper()}
+#endif
+
+const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_{image_name.upper()} uint8_t {image_name}_bin[] = {{
+"""
+
+    # 将二进制数据转换为C数组格式
+    for i, byte in enumerate(bin_data):
+        if i % 12 == 0:
+            c_file_content += '\n  '
+        c_file_content += f'0x{byte:02x}, '
+
+    c_file_content = c_file_content.rstrip(', ')  # 移除最后一个逗号和空格
+    c_file_content += '\n};\n\n'
+
+    # 添加图像描述符
+    c_file_content += f"""const lv_img_dsc_t {image_name} = {{
+  .header.cf = LV_IMG_CF_RAW_CHROMA_KEYED,
+  .header.always_zero = 0,
+  .header.reserved = 0,
+  .header.w = {image_width},
+  .header.h = {image_height},
+  .data_size = {len(bin_data)},
+  .data = {image_name}_bin,
+}};
+"""
+
+    # 写入C文件
+    with open(lvgl_file, 'w') as c_file:
+        c_file.write(c_file_content)
+

qgif-0.1.0/qgif/gif2png.py

@@ -0,0 +1,135 @@
+# coding: utf-8
+import sys
+import os
+from PIL import Image, ImageFilter
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+
+def map_strength_to_parameters(strength):
+    if strength < 0 or strength > 10:
+        raise ValueError("强度值应在0到10之间")
+
+    # 非线性映射，使用指数函数控制强度
+    min_sigma = 0.00001  # 极低时接近不处理
+    max_sigma = 25.0  # 高强度时的最大滤波参数
+
+    sigma = min_sigma + (max_sigma - min_sigma) * (strength / 10.0)
+    return sigma
+
+def apply_bilateral_filter(image, strength):
+    image_cv = np.array(image)
+    image_cv = cv2.cvtColor(image_cv, cv2.COLOR_RGB2BGR)
+    sigma = map_strength_to_parameters(strength)
+    filtered_image_cv = cv2.bilateralFilter(image_cv, d=5, sigmaColor=sigma, sigmaSpace=sigma)
+    filtered_image_cv = cv2.cvtColor(filtered_image_cv, cv2.COLOR_BGR2RGB)
+    return Image.fromarray(filtered_image_cv)
+
+def reduce_quantization_noise(image, strength=10):
+    image_cv = np.array(image)
+    image_lab = cv2.cvtColor(image_cv, cv2.COLOR_RGB2Lab)
+    L, a, b = cv2.split(image_lab)
+    L_filtered = cv2.bilateralFilter(L, d=9, sigmaColor=strength, sigmaSpace=strength)
+    image_filtered = cv2.merge((L_filtered, a, b))
+    image_rgb = cv2.cvtColor(image_filtered, cv2.COLOR_Lab2RGB)
+    return Image.fromarray(image_rgb)
+
+def apply_interframe_median_filter(prev_frame, curr_frame, next_frame, threshold):
+    prev_frame_np = np.array(prev_frame)
+    curr_frame_np = np.array(curr_frame)
+    next_frame_np = np.array(next_frame)
+    mask = (np.abs(curr_frame_np - prev_frame_np) < threshold) & (prev_frame_np == next_frame_np)
+    curr_frame_np[mask] = prev_frame_np[mask]
+    return Image.fromarray(curr_frame_np)
+
+def apply_temporal_denoise(display_frame, curr_frame, threshold):
+    display_frame_np = np.array(display_frame)
+    curr_frame_np = np.array(curr_frame)
+    mask = np.abs(curr_frame_np - display_frame_np) < threshold
+    curr_frame_np[mask] = display_frame_np[mask]
+    return Image.fromarray(curr_frame_np)
+
+def crop_and_resize(image, crop_size=None, scale_size=None):
+    if crop_size:
+        width, height = image.size
+        crop_width, crop_height = crop_size
+        left = (width - crop_width) / 2
+        top = (height - crop_height) / 2
+        right = (width + crop_width) / 2
+        bottom = (height + crop_height) / 2
+        image = image.crop((left, top, right, bottom))
+
+    if scale_size:
+        image = image.resize(scale_size, Image.BILINEAR)
+
+    return image
+
+def extract_frames(gif_path, output_dir, crop_size=None, scale_size=None,
+        bilateral_strength=0, median_strength=0, interframe_threshold=0, temporal_threshold=0):
+    gif = Image.open(gif_path)
+
+    gif_info = {}
+    gif_info["frames"] = gif.n_frames
+    gif_info["duration"] = gif.info["duration"] # 获取第一帧的持续时间
+
+    width, height = gif.size
+    if crop_size is not None:
+        width, height = crop_size
+    if scale_size is not None:
+        width, height = scale_size
+    gif_info["width"], gif_info["height"] = width, height
+
+    if gif_info["width"] % 4 != 0 or gif_info["height"] % 4 != 0:
+        print(f"img width {gif_info['width']} or height {gif_info['height']} is incorrect, must be aligned to 4")
+        sys.exit(1)
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    frames = []
+    display_frame = None
+    frame_count = 0
+    try:
+        while True:
+            frame = gif.convert("RGB")
+
+            # 裁剪和缩放处理
+            frame = crop_and_resize(frame, crop_size=crop_size, scale_size=scale_size)
+
+            # 双边滤波处理
+            if bilateral_strength > 0:
+                frame = apply_bilateral_filter(frame, bilateral_strength)
+
+            # 空域中值滤波处理
+            if median_strength > 0:
+                frame = frame.filter(ImageFilter.MedianFilter(size=int(median_strength * 2 + 1)))
+
+            frames.append(frame)
+            frame_count += 1
+            gif.seek(gif.tell() + 1)
+    except EOFError:
+        pass
+
+    # 时域中值滤波
+    if len(frames) > 1 and interframe_threshold > 0:
+        prev_frame = frames[-1]
+        for frame_index in tqdm(range(len(frames)), desc="Applying interframe median filter"):
+            next_frame = frames[(frame_index + 1) % len(frames)]
+            frames[frame_index] = apply_interframe_median_filter(prev_frame, frames[frame_index], next_frame, interframe_threshold)
+            prev_frame = frames[frame_index]
+
+    # 时域不更新算法
+    if temporal_threshold > 0:
+        for frame_index in tqdm(range(len(frames)), desc="Applying temporal denoise"):
+            if display_frame is not None:
+                frames[frame_index] = apply_temporal_denoise(display_frame, frames[frame_index], temporal_threshold)
+            display_frame = frames[frame_index]
+
+    for frame_index, frame in tqdm(enumerate(frames), total=frame_count, desc="Saving frames"):
+        png_filename = f"{os.path.splitext(os.path.basename(gif_path))[0]}_{frame_index}.png"
+        png_path = os.path.join(output_dir, png_filename)
+        frame.save(png_path, "PNG")
+
+    return gif_info
+

qgif-0.1.0/qgif/qgif

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import argparse
+
+from qgif import VERSION
+from qgif.qgif import convert_gif_to_qgif, decode_qgif
+
+def check_range(param_name, t):
+    def checker(value):
+        value = t(value)
+        if value < 0 or value > 10:
+            raise argparse.ArgumentTypeError(f"Argument '{param_name}' must be between 0 and 10, but got {value}")
+        return value
+    return checker
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(prog="qgif", description="QGIF generator and decoder")
+    subparsers = parser.add_subparsers(dest="command")
+
+    parser_convert = subparsers.add_parser("convert", help="Convert GIF to QGIF.")
+    parser_convert.add_argument("-f", "--format", required=True, choices=["gx64", "gx96"], help="The format of generated QGIF frames.")
+    parser_convert.add_argument("-i", "--input", required=True, help="The input GIF file name.")
+    parser_convert.add_argument("-o", "--output", required=True, help="Generated QGIF file name.")
+    parser_convert.add_argument("-fr", "--framerate", type=int, default=0, help="The frame rate of QGIF file. (default: same as GIF)")
+    parser_convert.add_argument("-l", "--lvgl", action="store_true", help="Generate LVGL C file.")
+    parser_convert.add_argument("--crop-size", type=int, nargs=2, help="Size to crop the image (width height)")
+    parser_convert.add_argument("--scale-size", type=int, nargs=2, help="Size to scale the image (width height)")
+    parser_convert.add_argument("--bilateral-strength", default=0, type=check_range("--bilateral-strength", float),
+            help="Strength of bilateral filter (0-10, can be a float)")
+    parser_convert.add_argument("--median-strength", default=0, type=check_range("--median-strength", int),
+            help="Strength of spatial median filter (0-10)")
+    parser_convert.add_argument("--interframe-threshold", default=0, type=check_range("--interframe-threshold", int),
+            help="Threshold for interframe median filtering (0-10)")
+    parser_convert.add_argument("--temporal-threshold", default=0, type=check_range("--temporal-threshold", int),
+            help="Threshold for temporal denoise (0-10)")
+
+    parser_decode = subparsers.add_parser("decode", help="Decode QGIF to frames.")
+    parser_decode.add_argument("-i", "--input", required=True, help="The input QGIF file name.")
+    parser_decode.add_argument("-o", "--output", required=True, help="The directory of output frames and pngs.")
+    parser_decode.add_argument("-c", "--colordepth", type=int, required=True, choices=[16, 32], help="The color depth of decoded frames.")
+
+    parser.add_argument("-V", "--version", action="version", version="qgif %s" % VERSION)
+
+    args = parser.parse_args()
+    if args.command == "convert":
+        convert_gif_to_qgif(args.input,
+                args.output,
+                args.format,
+                args.lvgl,
+                args.framerate,
+                crop_size=args.crop_size,
+                scale_size=args.scale_size,
+                bilateral_strength=args.bilateral_strength,
+                median_strength=args.median_strength,
+                interframe_threshold=args.interframe_threshold,
+                temporal_threshold=args.temporal_threshold)
+    elif args.command == "decode":
+        decode_qgif(args.input, args.output, args.colordepth)
+

qgif-0.1.0/qgif/qgif.py

@@ -0,0 +1,182 @@
+# coding: utf-8
+import os
+import sys
+import signal
+import ctypes
+from ctypes import CFUNCTYPE, c_int
+import numpy as np
+import time
+from PIL import Image
+from tqdm import tqdm
+
+from qgif.gif2png import extract_frames
+from qgif.gen_lvgl_file import gen_lvgl_file
+
+qgif_lib_path = os.path.join(os.path.dirname(__file__), "./qgif_C/libqgif.so")
+qgif_lib = ctypes.CDLL(qgif_lib_path)
+
+exit_flag = False
+def signal_handler(sig, frame):
+    global exit_flag
+    exit_flag = True
+    sys.exit(1)
+
+signal.signal(signal.SIGINT, signal_handler)
+
+def get_filename_without_extension(file_path):
+    file_name_with_extension = os.path.basename(file_path)
+    file_name, _ = os.path.splitext(file_name_with_extension)
+    return file_name
+
+def replace_extension(file_path, extension):
+    base = os.path.splitext(file_path)[0]
+    return base + extension
+
+def get_compress_type_value(compress_type):
+    # 0: gx64
+    # 1: gx64a
+    # 2: gx96
+    # 3: gx96a
+    compress_types = {
+        "gx64" : 0,
+        "gx96" : 2,
+    }
+    return compress_types[compress_type]
+
+"""
+void compress_video(const char *image_path, const char *output_path, uint8_t compress_type, uint8_t frame_rate, int (*progress_callback)(int));
+"""
+qgif_lib.compress_video.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_uint8, ctypes.c_uint8, CFUNCTYPE(c_int, c_int)]
+qgif_lib.compress_video.restype = None
+
+
+"""
+void decode_qgif(const char *input_path, const char *output_path, unsigned char color_depth, int *width, int *height);
+"""
+qgif_lib.decode_qgif.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_uint8,
+        ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)]
+qgif_lib.decode_qgif.restype = None
+
+
+def convert_gif_to_qgif(input_path, output_path, qgif_format, need_output_lvgl, frame_rate=0,\
+        crop_size=None, scale_size=None, bilateral_strength=0, median_strength=0,\
+        interframe_threshold=0, temporal_threshold=0):
+    png_path = "_tmp"
+    if not os.path.exists(png_path):
+        os.makedirs(png_path)
+    input_name = get_filename_without_extension(input_path)
+    input_png_path = os.path.join(png_path, f"{input_name}_X.png")
+
+    # gif to png
+    print("Convert gif to png ...")
+    gif_info = extract_frames(input_path, png_path, crop_size, scale_size, bilateral_strength, median_strength,
+            interframe_threshold, temporal_threshold)
+    print("Convert gif to png finish.")
+
+    # png to qgif
+    print("Convert png to qgif ...")
+    progress_bar = tqdm(total=gif_info["frames"])
+
+    if frame_rate < 1 or frame_rate > 64:
+        frame_rate = int(1000. / gif_info["duration"])
+
+    global exit_flag
+    def progress_callback(frame_index):
+        progress_bar.n = frame_index
+        progress_bar.refresh()
+        if exit_flag:
+            return True
+        else:
+            return False
+
+    PROGRESS_CALLBACK = CFUNCTYPE(c_int, c_int)
+    c_progress_callback = PROGRESS_CALLBACK(progress_callback)
+
+    compress_type_value = get_compress_type_value(qgif_format)
+    qgif_lib.compress_video(input_png_path.encode("utf-8"), output_path.encode("utf-8"), compress_type_value,
+            frame_rate, c_progress_callback)
+    os.system(f"rm -r {png_path}")
+    progress_bar.close()
+    if exit_flag:
+        sys.exit(1)
+    print(f"Convert png to qgif {output_path} finish.")
+
+    if need_output_lvgl:
+        print("Generate LVGL C file ...")
+        bin_path = output_path
+        lvgl_path = replace_extension(bin_path, ".c")
+        gen_lvgl_file(bin_path, lvgl_path, gif_info["width"], gif_info["height"])
+        print(f"Generate LVGL C file {lvgl_path} finish.")
+
+    print(f"============================")
+    print(f"QGIF {output_path}:")
+    print(f"frames: {gif_info['frames']}")
+    print(f"framerate: {frame_rate}")
+    print(f"img width: {gif_info['width']}, height: {gif_info['height']}")
+    print(f"============================")
+
+def decode_qgif(input_path, output_path, color_depth):
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+    output_frame_path = os.path.join(output_path, "frames")
+    if not os.path.exists(output_frame_path):
+        os.makedirs(output_frame_path)
+    output_png_path = os.path.join(output_path, "pngs")
+    if not os.path.exists(output_png_path):
+        os.makedirs(output_png_path)
+
+    print("Decode qgif to frames ...")
+    width = ctypes.c_int()
+    height = ctypes.c_int()
+    qgif_lib.decode_qgif(input_path.encode("utf-8"), output_frame_path.encode("utf-8"), color_depth,
+            ctypes.byref(width), ctypes.byref(height))
+    print("Decode qgif to frames finish.")
+
+    print("Save frames to pngs ...")
+    display_images(output_frame_path, output_png_path, width.value, height.value, color_depth)
+    print("Save frames to pngs finish.")
+
+
+def rgb565_to_rgb888(rgb565):
+    rgb565 = ((rgb565 >> 8) & 0xff) | ((rgb565 & 0xff) << 8)
+    r = ((rgb565 >> 11) & 0x1F) << 3
+    g = ((rgb565 >> 5) & 0x3F) << 2
+    b = (rgb565 & 0x1F) << 3
+    return (r, g, b)
+
+def convert_rgb888_to_image(data, width, height):
+    img = Image.new("RGB", (width, height))
+    pixels = img.load()
+    for y in range(height):
+        for x in range(width):
+            index = y * width + x
+            pixels[x, y] = (data[index] & 0xff, (data[index] >> 8) & 0xff, (data[index] >> 16) & 0xff)
+    return img
+
+def convert_rgb565_to_image(data, width, height):
+    img = Image.new("RGB", (width, height))
+    pixels = img.load()
+    for y in range(height):
+        for x in range(width):
+            index = y * width + x
+            rgb565 = data[index]
+            pixels[x, y] = rgb565_to_rgb888(rgb565)
+    return img
+
+def display_images(frame_folder, png_folder, width, height, color_depth):
+    files = [f for f in os.listdir(frame_folder) if f.endswith(".rgb")]
+    files = [f for f in files if f.split(".")[0].isdigit()]
+    sorted_files = sorted(files, key=lambda x: int(x.split(".")[0]))
+
+    for image_file in tqdm(sorted_files):
+        with open(os.path.join(frame_folder, image_file), "rb") as f:
+            rgb_image = f.read()
+            if color_depth == 32:
+                rgb888_data = np.frombuffer(rgb_image, dtype=np.uint32)
+                img = convert_rgb888_to_image(rgb888_data, width, height)
+            elif color_depth == 16:
+                rgb565_data = np.frombuffer(rgb_image, dtype=np.uint16)
+                img = convert_rgb565_to_image(rgb565_data, width, height)
+            image_name = get_filename_without_extension(image_file)
+            img.save(os.path.join(png_folder, image_name + ".png"))
+

qgif-0.1.0/qgif.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: qgif
+Version: 0.1.0
+Summary: Convert GIF to QGIF, or decode QGIF.
+Author: Hangzhou Nationalchip Inc.
+Author-email: zhengdi@nationalchip.com
+License: MIT Licence
+Keywords: qgif nationalchip
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3

qgif-0.1.0/qgif.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+setup.py
+qgif/__init__.py
+qgif/__main__.py
+qgif/gen_lvgl_file.py
+qgif/gif2png.py
+qgif/qgif
+qgif/qgif.py
+qgif.egg-info/PKG-INFO
+qgif.egg-info/SOURCES.txt
+qgif.egg-info/dependency_links.txt
+qgif.egg-info/requires.txt
+qgif.egg-info/top_level.txt
+qgif/qgif_C/libqgif.so

qgif-0.1.0/qgif.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qgif-0.1.0/qgif.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+pillow
+tqdm
+opencv-python

qgif-0.1.0/qgif.egg-info/top_level.txt

@@ -0,0 +1 @@
+qgif

qgif-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qgif-0.1.0/setup.py

@@ -0,0 +1,54 @@
+# Copyright 2024 The QGIF Authors. All Rights Reserved.
+#
+# Licensed under the Proprietary License;
+# you may not use this file except in compliance with the License.
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from setuptools import find_packages, setup
+from setuptools.command.build_py import build_py
+import os
+
+from qgif import VERSION
+
+REQUIRED_PACKAGES = [
+    'numpy',
+    'pillow',
+    'tqdm',
+    'opencv-python'
+]
+
+setup(
+    name='qgif',
+    version=VERSION,
+    description='Convert GIF to QGIF, or decode QGIF.',
+    author='Hangzhou Nationalchip Inc.',
+    author_email='zhengdi@nationalchip.com',
+    license='MIT Licence',
+
+    # PyPI package information.
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        ],
+
+    keywords='qgif nationalchip',
+
+    # Contained modules and scripts.
+    packages=find_packages(),
+    install_requires=REQUIRED_PACKAGES,
+
+    package_data={
+        'qgif': ['qgif_C/libqgif.so']
+    },
+    scripts=['qgif/qgif'],
+    entry_points={
+    },
+)