minor update

This reverts commit dbed079fa40fd25296609d927509c0d646b1eeae.

3rd/cute_png/src/cute_png.c

@@ -4,6 +4,14 @@
 #define CUTE_PNG_IMPLEMENTATION
 #include "cute_png.h"
 
+#if PY_SYS_PLATFORM == 5
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <linux/fb.h>
+#endif
+
 static bool cute_png_loads(int argc, py_Ref argv) {
     PY_CHECK_ARGC(1);
     PY_CHECK_ARG_TYPE(0, tp_bytes);
@@ -192,27 +200,114 @@ static bool cute_png_Image__to_rgb565_file(int argc, py_Ref argv) {
     PY_CHECK_ARG_TYPE(1, tp_str);
     cp_image_t* image = py_touserdata(argv);
     const char* path = py_tostr(py_arg(1));
-    FILE* fp = fopen(path, "wb");
-    if(fp == NULL) return OSError("cannot open file '%s' for writing", path);
-    size_t size = 0;
-    for(int y = 0; y < image->h; y++) {
-        for(int x = 0; x < image->w; x++) {
-            size_t idx = y * image->w + x;
-            cp_pixel_t pixel = image->pix[idx];
-            uint16_t r = (pixel.r >> 3) & 0x1F;
-            uint16_t g = (pixel.g >> 2) & 0x3F;
-            uint16_t b = (pixel.b >> 3) & 0x1F;
-            uint16_t rgb565 = (r << 11) | (g << 5) | b;
-            // use little-endian
-            size_t delta = fwrite(&rgb565, 1, 2, fp);
-            size += delta;
-            if(delta != 2) {
+
+#define CONVERT_TO_RGB565(__block)                                                                 \
+    size_t size = 0;                                                                               \
+    for(int y = 0; y < image->h; y++) {                                                            \
+        for(int x = 0; x < image->w; x++) {                                                        \
+            size_t idx = y * image->w + x;                                                         \
+            cp_pixel_t pixel = image->pix[idx];                                                    \
+            uint16_t r = (pixel.r >> 3) & 0x1F;                                                    \
+            uint16_t g = (pixel.g >> 2) & 0x3F;                                                    \
+            uint16_t b = (pixel.b >> 3) & 0x1F;                                                    \
+            uint16_t rgb565 = (r << 11) | (g << 5) | b;                                            \
+            __block                                                                                \
+        }                                                                                          \
+    }
+
+#if PY_SYS_PLATFORM == 5
+    if(strcmp(path, "/dev/fb0") == 0) {
+        static struct fb_fix_screeninfo finfo;
+        static uint8_t* vmem_base;
+        if(vmem_base == NULL) {
+            int fbdev_fd = open(path, O_RDWR);
+            if(fbdev_fd < 0) return OSError("open() '/dev/fb0' failed");
+            fcntl(fbdev_fd, F_SETFD, fcntl(fbdev_fd, F_GETFD) | FD_CLOEXEC);
+            if(ioctl(fbdev_fd, FBIOGET_FSCREENINFO, &finfo) < 0) {
+                close(fbdev_fd);
+                return OSError("ioctl() '/dev/fb0' failed");
+            }
+            vmem_base = mmap(0, finfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fbdev_fd, 0);
+            if(vmem_base == MAP_FAILED) {
+                vmem_base = NULL;
+                close(fbdev_fd);
+                return OSError("mmap() '/dev/fb0' failed");
+            }
+            close(fbdev_fd);
+        }
+        CONVERT_TO_RGB565(
+            // use little endian
+            if(size + 2 > finfo.smem_len) {
                 py_newint(py_retval(), size);
                 return true;
+            } memcpy(vmem_base + size, &rgb565, 2);
+            size += 2;)
+        py_newint(py_retval(), size);
+        return true;
+    }
+#endif
+
+    FILE* fp = fopen(path, "wb");
+    if(fp == NULL) return OSError("cannot open file '%s' for writing", path);
+    CONVERT_TO_RGB565(
+        // use little endian
+        size += fwrite(&rgb565, 1, 2, fp);)
+    fclose(fp);
+    py_newint(py_retval(), size);
+    return true;
+#undef CONVERT_TO_RGB565
+}
+
+static bool cute_png_Image__paste(int argc, py_Ref argv) {
+    PY_CHECK_ARGC(8);
+    PY_CHECK_ARG_TYPE(1, py_gettype("cute_png", py_name("Image")));  // src_img
+    PY_CHECK_ARG_TYPE(2, tp_vec2i);                                  // src_pos
+    PY_CHECK_ARG_TYPE(3, tp_vec2i);                                  // dst_pos
+    PY_CHECK_ARG_TYPE(4, tp_int);                                    // width
+    PY_CHECK_ARG_TYPE(5, tp_int);                                    // height
+    PY_CHECK_ARG_TYPE(6, tp_color32);                                // fg
+    PY_CHECK_ARG_TYPE(7, tp_color32);                                // bg
+
+    cp_image_t* dst_image = py_touserdata(argv);
+    cp_image_t* src_image = py_touserdata(py_arg(1));
+    c11_vec2i src_pos = py_tovec2i(py_arg(2));
+    c11_vec2i dst_pos = py_tovec2i(py_arg(3));
+    int width = py_toint(py_arg(4));
+    int height = py_toint(py_arg(5));
+    c11_color32 fg = py_tocolor32(py_arg(6));
+    c11_color32 bg = py_tocolor32(py_arg(7));
+
+    for(int y = 0; y < height; y++) {
+        for(int x = 0; x < width; x++) {
+            int src_x = src_pos.x + x;
+            int src_y = src_pos.y + y;
+            int dst_x = dst_pos.x + x;
+            int dst_y = dst_pos.y + y;
+
+            if(src_x >= src_image->w || src_y >= src_image->h) continue;
+            if(dst_x >= dst_image->w || dst_y >= dst_image->h) continue;
+
+            // fill with bg color first
+            cp_pixel_t dst_pixel = cp_make_pixel_a(bg.r, bg.g, bg.b, 255);
+
+            // override with fg * src_pixel
+            cp_pixel_t src_pixel = src_image->pix[src_y * src_image->w + src_x];
+            src_pixel.r = (src_pixel.r * (int)fg.r) / 255;
+            src_pixel.g = (src_pixel.g * (int)fg.g) / 255;
+            src_pixel.b = (src_pixel.b * (int)fg.b) / 255;
+
+            // alpha blend
+            if(src_pixel.a > 0) {
+                float alpha = src_pixel.a / 255.0f;
+                dst_pixel.r = (uint8_t)(src_pixel.r * alpha + dst_pixel.r * (1.0f - alpha));
+                dst_pixel.g = (uint8_t)(src_pixel.g * alpha + dst_pixel.g * (1.0f - alpha));
+                dst_pixel.b = (uint8_t)(src_pixel.b * alpha + dst_pixel.b * (1.0f - alpha));
             }
+
+            dst_image->pix[dst_y * dst_image->w + dst_x] = dst_pixel;
         }
     }
-    py_newint(py_retval(), size);
+    py_newnone(py_retval());
     return true;
 }
 
@@ -235,6 +330,8 @@ void pk__add_module_cute_png() {
     py_bindmethod(tp_image, "getpixel", cute_png_Image__getpixel);
     py_bindmethod(tp_image, "clear", cute_png_Image__clear);
 
+    py_bindmethod(tp_image, "paste", cute_png_Image__paste);
+
     py_bindmethod(tp_image, "to_png_bytes", cute_png_Image__to_png_bytes);
     py_bindmethod(tp_image, "to_png_file", cute_png_Image__to_png_file);
     py_bindmethod(tp_image, "to_rgb565_file", cute_png_Image__to_rgb565_file);

include/typings/cute_png.pyi

@@ -1,5 +1,5 @@
 from array2d import array2d
-from vmath import color32
+from vmath import color32, vec2i
 
 class Image:
     @property
@@ -18,6 +18,8 @@ class Image:
     def getpixel(self, x: int, y: int) -> color32: ...
     def clear(self, color: color32) -> None: ...
 
+    def paste(self, src_img: "Image", src_pos: vec2i, dst_pos: vec2i, width: int, height: int, fg: color32, bg: color32) -> None: ...
+
     def to_png_bytes(self) -> bytes: ...
     def to_png_file(self, path: str) -> int: ...
     def to_rgb565_file(self, path: str) -> int: ...

include/typings/io.pyi

@@ -1,17 +0,0 @@
-
-class FileIO:
-    def __new__(cls, file: str, mode: str) -> "FileIO": ...
-
-    def __enter__(self) -> "FileIO": ...
-    def __exit__(self) -> None: ...
-
-    def read(self, size: int | None = None) -> bytes: ...
-    def write(self, data: bytes) -> int: ...
-    def close(self) -> None: ...
-    def tell(self) -> int: ...
-    def seek(self, offset: int, whence: int) -> None: ...
-    def flush(self) -> None: ...
-
-SEEK_SET: int
-SEEK_CUR: int
-SEEK_END: int

src2/main.c

@@ -94,18 +94,16 @@ int main(int argc, char** argv) {
 
         char* source = read_file(filename);
         if(source) {
-            if(!py_exec(source, filename, EXEC_MODE, NULL))
-                py_printexc();
-            else {
-                if(profile) {
-                    char* json_report = py_profiler_report();
-                    FILE* report_file = fopen("profiler_report.json", "w");
-                    if(report_file) {
-                        fprintf(report_file, "%s", json_report);
-                        fclose(report_file);
-                    }
-                    PK_FREE(json_report);
+            if(!py_exec(source, filename, EXEC_MODE, NULL)) py_printexc();
+
+            if(profile) {
+                char* json_report = py_profiler_report();
+                FILE* report_file = fopen("profiler_report.json", "w");
+                if(report_file) {
+                    fprintf(report_file, "%s", json_report);
+                    fclose(report_file);
                 }
+                PK_FREE(json_report);
             }
 
             PK_FREE(source);