.gitlab-ci.yml

 stages:
-  - check
   - build
   - deploy
 
@@ -12,30 +11,13 @@ default:
   #     docker load < $(nix-build nix/docker-image.nix)
   image: registry.k0.hswaw.net/q3k/flow3r-build:ymrsh8w1z9l89qvvksw52k7sl54lx73q
 
-clang-tidy:
-  stage: check
-  script:
-    - "bash tools/clang-tidy.sh"
-    - "python3 tools/codequal-report.py clang-tidy warnings.txt > cqual.json"
-  artifacts:
-    when: always
-    reports:
-      codequality: cqual.json
-
-format:
-  stage: check
-  script:
-    - "git clean -fdx"
-    - "bash tools/format.sh"
-    - "[ -z \"$(git status --porcelain)\" ] || (echo 'Differences found, please run tools/format.sh.' && git diff HEAD && exit 1)"
-
 build:
   stage: build
   script:
     - idf.py -g c23 build size
   artifacts:
     expose_as: 'firmware'
-    paths: ['build/flow3r.bin']
+    paths: ['build/flow3r.bin', 'build/flow3r.elf']
     expire_in: 5 hours
 
 build_recovery:
@@ -48,15 +30,6 @@ build_recovery:
     paths: ['recovery/build/flow3r-recovery.bin', 'recovery/build/partition_table/partition-table.bin', 'recovery/build/bootloader/bootloader.bin']
     expire_in: 5 hours
 
-simulate:
-  stage: build
-  script:
-    - python3 sim/run.py --screenshot
-  artifacts:
-    expose_as: 'Simulator Screenshot'
-    paths: ['flow3r.png']
-    expire_in: 5 hours
-
 pages:
   stage: deploy
   only:

components/ctx/ctx_config.h

@@ -45,7 +45,7 @@
 #define CTX_BAREMETAL                      1
 #define CTX_ONE_FONT_ENGINE                1
 
-#define CTX_MAX_SCANLINE_LENGTH            256
+#define CTX_MAX_SCANLINE_LENGTH            960
 #define CTX_MAX_JOURNAL_SIZE               (1024*512)
 // is also max and limits complexity
 // of paths that can be filled

components/micropython/usermodule/mp_sys_display.c

@@ -29,6 +29,13 @@ STATIC mp_obj_t mp_overlay_clip(size_t n_arge, const mp_obj_t *args) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_overlay_clip_obj, 4, 4,
                                            mp_overlay_clip);
 
+STATIC mp_obj_t mp_fbconfig(size_t n_arge, const mp_obj_t *args) {
+    st3m_gfx_fbconfig(mp_obj_get_int(args[0]), mp_obj_get_int(args[1]),
+                      mp_obj_get_int(args[2]), mp_obj_get_int(args[3]));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_fbconfig_obj, 4, 4, mp_fbconfig);
+
 STATIC mp_obj_t mp_set_backlight(mp_obj_t percent_in) {
     uint8_t percent = mp_obj_get_int(percent_in);
     flow3r_bsp_display_set_backlight(percent);
@@ -136,6 +143,7 @@ STATIC const mp_rom_map_elem_t mp_module_sys_display_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_set_palette), MP_ROM_PTR(&mp_set_palette_obj) },
     { MP_ROM_QSTR(MP_QSTR_set_backlight), MP_ROM_PTR(&mp_set_backlight_obj) },
     { MP_ROM_QSTR(MP_QSTR_overlay_clip), MP_ROM_PTR(&mp_overlay_clip_obj) },
+    { MP_ROM_QSTR(MP_QSTR_fbconfig), MP_ROM_PTR(&mp_fbconfig_obj) },
 
     { MP_ROM_QSTR(MP_QSTR_default), MP_ROM_INT((int)st3m_gfx_default) },
     { MP_ROM_QSTR(MP_QSTR_rgb332), MP_ROM_INT((int)st3m_gfx_rgb332) },

components/micropython/vendor/ports/esp32/gccollect.c

@@ -61,6 +61,7 @@ static void gc_collect_inner(int level) {
 }
 
 void gc_collect(void) {
+    printf("gc_collect\n");
     gc_collect_start();
     gc_collect_inner(0);
     gc_collect_end();

components/micropython/vendor/py/builtinimport.c

@@ -276,7 +276,6 @@ STATIC void evaluate_relative_import(mp_int_t level, const char **module_name, s
     // "Relative imports use a module's __name__ attribute to determine that
     // module's position in the package hierarchy."
     // http://legacy.python.org/dev/peps/pep-0328/#relative-imports-and-name
-
     mp_obj_t current_module_name_obj = mp_obj_dict_get(MP_OBJ_FROM_PTR(mp_globals_get()), MP_OBJ_NEW_QSTR(MP_QSTR___name__));
     assert(current_module_name_obj != MP_OBJ_NULL);
 
@@ -292,12 +291,10 @@ STATIC void evaluate_relative_import(mp_int_t level, const char **module_name, s
     // If we have a __path__ in the globals dict, then we're a package.
     bool is_pkg = mp_map_lookup(&mp_globals_get()->map, MP_OBJ_NEW_QSTR(MP_QSTR___path__), MP_MAP_LOOKUP);
 
-    #if DEBUG_PRINT
-    DEBUG_printf("Current module/package: ");
-    mp_obj_print_helper(MICROPY_DEBUG_PRINTER, current_module_name_obj, PRINT_REPR);
-    DEBUG_printf(", is_package: %d", is_pkg);
-    DEBUG_printf("\n");
-    #endif
+    printf("Current module/package: ");
+    mp_obj_print_helper(&mp_plat_print, current_module_name_obj, PRINT_REPR);
+    printf(", is_package: %d", is_pkg);
+    printf("\n");
 
     size_t current_module_name_len;
     const char *current_module_name = mp_obj_str_get_data(current_module_name_obj, &current_module_name_len);
@@ -341,7 +338,7 @@ STATIC void evaluate_relative_import(mp_int_t level, const char **module_name, s
     qstr new_mod_q = qstr_from_strn(new_mod, new_module_name_len);
     mp_local_free(new_mod);
 
-    DEBUG_printf("Resolved base name for relative import: '%s'\n", qstr_str(new_mod_q));
+    printf("Resolved base name for relative import: '%s'\n", qstr_str(new_mod_q));
     *module_name = qstr_str(new_mod_q);
     *module_name_len = new_module_name_len;
 }
@@ -476,14 +473,15 @@ STATIC mp_obj_t process_import_at_level(qstr full_mod_name, qstr level_mod_name,
 }
 
 mp_obj_t mp_builtin___import___default(size_t n_args, const mp_obj_t *args) {
-    #if DEBUG_PRINT
-    DEBUG_printf("__import__:\n");
+    /*printf("__import__: %p %p %s\n", args[0], mp_obj_str_get_str(args[0]), mp_obj_str_get_str(args[0]));
+    size_t len;
+    const char* data = mp_obj_str_get_data(args[0], &len);
+    /rintf(" - %d %s\n", (int)len, data);
     for (size_t i = 0; i < n_args; i++) {
-        DEBUG_printf("  ");
-        mp_obj_print_helper(MICROPY_DEBUG_PRINTER, args[i], PRINT_REPR);
-        DEBUG_printf("\n");
-    }
-    #endif
+        printf("  ");
+        mp_obj_print_helper(&mp_plat_print, args[i], PRINT_REPR);
+        printf("\n");
+    }*/
 
     // This is the import path, with any leading dots stripped.
     // "import foo.bar" --> module_name="foo.bar"
@@ -507,7 +505,7 @@ mp_obj_t mp_builtin___import___default(size_t n_args, const mp_obj_t *args) {
         if (n_args >= 5) {
             level = MP_OBJ_SMALL_INT_VALUE(args[4]);
             if (level < 0) {
-                mp_raise_ValueError(NULL);
+                mp_raise_ValueError(MP_ERROR_TEXT("foo"));
             }
         }
     }
@@ -521,10 +519,10 @@ mp_obj_t mp_builtin___import___default(size_t n_args, const mp_obj_t *args) {
     }
 
     if (module_name_len == 0) {
-        mp_raise_ValueError(NULL);
+        mp_raise_ValueError(MP_ERROR_TEXT("bar"));
     }
 
-    DEBUG_printf("Starting module search for '%s'\n", module_name);
+    printf("Starting module search for '%s'\n", module_name);
 
     VSTR_FIXED(path, MICROPY_ALLOC_PATH_MAX)
     mp_obj_t top_module_obj = MP_OBJ_NULL;

components/micropython/vendor/py/qstr.c

@@ -137,6 +137,7 @@ STATIC const qstr_pool_t *find_qstr(qstr *q) {
 // qstr_mutex must be taken while in this function
 STATIC qstr qstr_add(mp_uint_t hash, mp_uint_t len, const char *q_ptr) {
     DEBUG_printf("QSTR: add hash=%d len=%d data=%.*s\n", hash, len, len, q_ptr);
+    gc_collect();
 
     // make sure we have room in the pool for a new qstr
     if (MP_STATE_VM(last_pool)->len >= MP_STATE_VM(last_pool)->alloc) {
@@ -165,7 +166,7 @@ STATIC qstr qstr_add(mp_uint_t hash, mp_uint_t len, const char *q_ptr) {
         pool->alloc = new_alloc;
         pool->len = 0;
         MP_STATE_VM(last_pool) = pool;
-        DEBUG_printf("QSTR: allocate new pool of size %d\n", MP_STATE_VM(last_pool)->alloc);
+        printf("QSTR: allocate new pool of size %d %p %p\n", (int)MP_STATE_VM(last_pool)->alloc, MP_STATE_VM(last_pool), MP_STATE_VM(qstr_last_chunk));
     }
 
     // add the new qstr
@@ -247,6 +248,7 @@ qstr qstr_from_strn(const char *str, size_t len) {
             }
             MP_STATE_VM(qstr_last_alloc) = al;
             MP_STATE_VM(qstr_last_used) = 0;
+            printf("qstr_last_chunk %p %p\n", MP_STATE_VM(qstr_last_chunk), MP_STATE_VM(last_pool));
         }
 
         // allocate memory from the chunk for this new interned string's data

components/micropython/vendor/py/runtime.c

@@ -1484,7 +1484,7 @@ mp_obj_t mp_make_raise_obj(mp_obj_t o) {
 }
 
 mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
-    DEBUG_printf("import name '%s' level=%d\n", qstr_str(name), MP_OBJ_SMALL_INT_VALUE(level));
+    printf("import name '%s' level=%ld\n", qstr_str(name), MP_OBJ_SMALL_INT_VALUE(level));
 
     // build args array
     mp_obj_t args[5];
@@ -1509,7 +1509,7 @@ mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
 }
 
 mp_obj_t mp_import_from(mp_obj_t module, qstr name) {
-    DEBUG_printf("import from %p %s\n", module, qstr_str(name));
+    printf("import from %p %s\n", module, qstr_str(name));
 
     mp_obj_t dest[2];
 
@@ -1543,7 +1543,7 @@ mp_obj_t mp_import_from(mp_obj_t module, qstr name) {
     memcpy(dot_name + pkg_name_len + 1, qstr_str(name), qstr_len(name));
     qstr dot_name_q = qstr_from_strn(dot_name, dot_name_len);
     mp_local_free(dot_name);
-
+    printf("aaaa %s\n", qstr_str(dot_name_q));
     // For fromlist, pass sentinel "non empty" value to force returning of leaf module
     return mp_import_name(dot_name_q, mp_const_true, MP_OBJ_NEW_SMALL_INT(0));
 
@@ -1556,7 +1556,7 @@ mp_obj_t mp_import_from(mp_obj_t module, qstr name) {
 }
 
 void mp_import_all(mp_obj_t module) {
-    DEBUG_printf("import all %p\n", module);
+    printf("import all %p\n", module);
 
     // TODO: Support __all__
     mp_map_t *map = &mp_obj_module_get_globals(module)->map;

components/st3m/st3m_gfx.c

@@ -90,6 +90,9 @@ typedef struct {
     int osd_y1;
     int osd_x1;
 
+    int blit_x;  // upper left pixel in framebuffer coordinates
+    int blit_y;  //
+
     st3m_gfx_mode mode;
     uint8_t *blit_src;
 } st3m_gfx_drawlist;
@@ -117,6 +120,12 @@ static TaskHandle_t graphics_blit_task;
 
 static int _st3m_gfx_low_latency = 0;
 
+static int st3m_gfx_fb_width = 0;
+static int st3m_gfx_fb_height = 0;
+static int st3m_gfx_blit_x = 0;
+static int st3m_gfx_blit_y = 0;
+static int st3m_gfx_geom_dirty = 0;
+
 static inline int st3m_gfx_scale(void) {
     st3m_gfx_mode set_mode = _st3m_gfx_mode ? _st3m_gfx_mode : default_mode;
     switch ((int)(set_mode & st3m_gfx_4x)) {
@@ -351,6 +360,8 @@ st3m_gfx_mode st3m_gfx_set_mode(st3m_gfx_mode mode) {
         ((mode & st3m_gfx_direct_ctx) != 0))
         _st3m_gfx_low_latency = (N_DRAWLISTS - 1);
 
+    st3m_gfx_fbconfig(240, 240, 0, 0);
+
     return mode;
 }
 
@@ -367,7 +378,7 @@ uint8_t *st3m_gfx_fb(st3m_gfx_mode mode, int *width, int *height, int *stride) {
         if (height) *height = 256;
         return st3m_pal;
     } else if (mode == st3m_gfx_default) {
-        if (stride) *stride = FLOW3R_BSP_DISPLAY_WIDTH * bpp / 8;
+        if (stride) *stride = st3m_gfx_fb_width * bpp / 8;
         if (width) *width = FLOW3R_BSP_DISPLAY_WIDTH;
         if (height) *height = FLOW3R_BSP_DISPLAY_HEIGHT;
         return ((uint8_t *)st3m_fb);
@@ -465,9 +476,11 @@ static void st3m_gfx_rast_task(void *_arg) {
 #if CONFIG_FLOW3R_CTX_FLAVOUR_FULL
         ctx_set_textureclock(osd_ctx, ctx_textureclock(fb_ctx));
 #endif
-        if (prev_set_mode != set_mode) {
+        if (st3m_gfx_geom_dirty || (prev_set_mode != set_mode)) {
+            int was_geom_dirty = (prev_set_mode == set_mode);
             bits = _st3m_gfx_bpp(set_mode);
             prev_set_mode = set_mode;
+            st3m_gfx_geom_dirty = 0;
 
 #if ST3M_GFX_BLIT_TASK
             if ((bits > 16))
@@ -475,33 +488,40 @@ static void st3m_gfx_rast_task(void *_arg) {
             else
                 direct_blit = 0;
 #endif
-            int stride = (bits * 240) / 8;
+
+            int stride = (bits * st3m_gfx_fb_width) / 8;
             switch (bits) {
 #if CONFIG_FLOW3R_CTX_FLAVOUR_FULL
                 case 1:
-                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0, 240, 240,
+                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0,
+                                          st3m_gfx_fb_width, st3m_gfx_fb_height,
                                           stride, CTX_FORMAT_GRAY1);
                     break;
                 case 2:
-                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0, 240, 240,
+                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0,
+                                          st3m_gfx_fb_width, st3m_gfx_fb_height,
                                           stride, CTX_FORMAT_GRAY2);
                     break;
                 case 4:
-                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0, 240, 240,
+                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0,
+                                          st3m_gfx_fb_width, st3m_gfx_fb_height,
                                           stride, CTX_FORMAT_GRAY4);
                     break;
                 case 8:
                 case 9:
                     if ((set_mode & 0xf) == 9)
-                        ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0, 240, 240,
-                                              stride, CTX_FORMAT_RGB332);
+                        ctx_rasterizer_reinit(
+                            fb_ctx, st3m_fb, 0, 0, st3m_gfx_fb_width,
+                            st3m_gfx_fb_height, stride, CTX_FORMAT_RGB332);
                     else
-                        ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0, 240, 240,
-                                              stride, CTX_FORMAT_GRAY8);
+                        ctx_rasterizer_reinit(
+                            fb_ctx, st3m_fb, 0, 0, st3m_gfx_fb_width,
+                            st3m_gfx_fb_height, stride, CTX_FORMAT_GRAY8);
                     break;
 #endif
                 case 16:
-                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0, 240, 240,
+                    ctx_rasterizer_reinit(fb_ctx, st3m_fb, 0, 0,
+                                          st3m_gfx_fb_width, st3m_gfx_fb_height,
                                           stride,
                                           CTX_FORMAT_RGB565_BYTESWAPPED);
                     break;
@@ -518,10 +538,10 @@ static void st3m_gfx_rast_task(void *_arg) {
 #endif
             }
             st3m_gfx_viewport_transform(fb_ctx);
-            memset(st3m_fb, 0, sizeof(st3m_fb));
+            if (!was_geom_dirty) memset(st3m_fb, 0, sizeof(st3m_fb));
 #if CONFIG_FLOW3R_CTX_FLAVOUR_FULL
             st3m_gfx_viewport_transform(osd_ctx);
-            memset(st3m_fb2, 0, sizeof(st3m_fb2));
+            if (!was_geom_dirty) memset(st3m_fb2, 0, sizeof(st3m_fb2));
 #endif
         }
 
@@ -541,7 +561,76 @@ static void st3m_gfx_rast_task(void *_arg) {
         } else {
             drawlist->blit_src = st3m_fb_copy;
             xSemaphoreTake(st3m_fb_copy_lock, portMAX_DELAY);
-            memcpy(st3m_fb_copy, st3m_fb, 240 * (240 * bits / 8));
+            int disp_stride = 240 * bits / 8;
+            if ((st3m_gfx_fb_width == 240) && (drawlist->blit_x == 0)) {
+                int blit_offset = st3m_gfx_blit_y * 240 * bits / 8;
+                int overlap = (st3m_gfx_blit_y + 240) - st3m_gfx_fb_height;
+
+                if (overlap > 0) {
+                    // vertical overlap, 2 memcpys
+                    int start_scans = 240 - overlap;
+                    memcpy(st3m_fb_copy, st3m_fb + blit_offset,
+                           start_scans * disp_stride);
+                    memcpy(st3m_fb_copy + start_scans * disp_stride, st3m_fb,
+                           overlap * disp_stride);
+                } else {  // best case
+                    memcpy(st3m_fb_copy, st3m_fb + blit_offset,
+                           240 * disp_stride);
+                }
+            } else {
+                int fb_stride = st3m_gfx_fb_width * bits / 8;
+                int scan_offset = drawlist->blit_x * bits / 8;
+                int scan_overlap = (drawlist->blit_x + 240) - st3m_gfx_fb_width;
+                if (scan_overlap <= 0) {  // only vertical wrap-around
+                    int blit_offset =
+                        (st3m_gfx_blit_y * 240 + drawlist->blit_x) * bits / 8;
+                    int overlap = (st3m_gfx_blit_y + 240) - st3m_gfx_fb_height;
+                    if (overlap <= 0) overlap = 0;
+
+                    int start_scans = 240 - overlap;
+                    for (int i = 0; i < start_scans; i++)
+                        memcpy(st3m_fb_copy + i * disp_stride,
+                               st3m_fb + blit_offset + i * fb_stride,
+                               disp_stride);
+                    for (int i = 0; i < overlap; i++)
+                        memcpy(st3m_fb_copy + (i + start_scans) * disp_stride,
+                               st3m_fb + (drawlist->blit_x * bits / 8) +
+                                   i * fb_stride,
+                               disp_stride);
+                } else {  // generic case, handles both horizontal and vertical
+                          // wrap-around
+                    int start_bit = 240 - scan_overlap;
+
+                    int blit_offset = (st3m_gfx_blit_y)*fb_stride;
+                    int overlap = (st3m_gfx_blit_y + 240) - st3m_gfx_fb_height;
+                    if (overlap <= 0) overlap = 0;
+
+                    int start_scans = 240 - overlap;
+                    int start_bytes = start_bit * bits / 8;
+                    int scan_overlap_bytes = scan_overlap * bits / 8;
+
+                    for (int i = 0; i < start_scans; i++)
+                        memcpy(
+                            st3m_fb_copy + i * disp_stride,
+                            st3m_fb + blit_offset + i * fb_stride + scan_offset,
+                            start_bytes);
+                    for (int i = 0; i < overlap; i++)
+                        memcpy(st3m_fb_copy + (i + start_scans) * disp_stride,
+                               st3m_fb + scan_offset + i * fb_stride,
+                               start_bytes);
+
+                    // second pass over scanlines, filling in second half (which
+                    // is wrapped to start of fb-scans)
+                    for (int i = 0; i < start_scans; i++)
+                        memcpy(st3m_fb_copy + i * disp_stride + start_bytes,
+                               st3m_fb + blit_offset + i * fb_stride,
+                               scan_overlap_bytes);
+                    for (int i = 0; i < overlap; i++)
+                        memcpy(st3m_fb_copy + (i + start_scans) * disp_stride +
+                                   start_bytes,
+                               st3m_fb + i * fb_stride, scan_overlap_bytes);
+                }
+            }
             xSemaphoreGive(st3m_fb_copy_lock);
             xSemaphoreGive(st3m_fb_lock);
             xQueueSend(user_ctx_blitq, &desc_no, portMAX_DELAY);
@@ -882,6 +971,8 @@ static void st3m_gfx_pipe_put(void) {
     drawlist->osd_y0 = _st3m_osd_y0;
     drawlist->osd_x1 = _st3m_osd_x1;
     drawlist->osd_y1 = _st3m_osd_y1;
+    drawlist->blit_x = st3m_gfx_blit_x;
+    drawlist->blit_y = st3m_gfx_blit_y;
 #endif
     xQueueSend(user_ctx_rastq, &last_descno, portMAX_DELAY);
 }
@@ -966,3 +1057,30 @@ void st3m_gfx_overlay_clip(int x0, int y0, int x1, int y1) {
     }
 }
 #endif
+
+void st3m_gfx_fbconfig(int width, int height, int blit_x, int blit_y) {
+    if (width <= 0) width = st3m_gfx_fb_width;
+    if (height <= 0) height = st3m_gfx_fb_height;
+    st3m_gfx_mode set_mode = _st3m_gfx_mode ? _st3m_gfx_mode : default_mode;
+    int bits = st3m_gfx_bpp(set_mode);
+    if (width > CTX_MAX_SCANLINE_LENGTH) width = CTX_MAX_SCANLINE_LENGTH;
+    if ((width * height * bits) / 8 > (240 * 240 * 4))
+        height = 240 * 240 * 4 * 8 / (width * bits);
+    blit_x %= width;
+    blit_y %= height;
+
+    if ((st3m_gfx_fb_width != width) || (st3m_gfx_fb_height != height)) {
+        st3m_gfx_fb_width = width;
+        st3m_gfx_fb_height = height;
+        st3m_gfx_geom_dirty++;
+    }
+    st3m_gfx_blit_x = blit_x;
+    st3m_gfx_blit_y = blit_y;
+}
+
+void st3m_gfx_get_fbconfig(int *width, int *height, int *blit_x, int *blit_y) {
+    if (width) *width = st3m_gfx_fb_width;
+    if (height) *height = st3m_gfx_fb_height;
+    if (blit_x) *blit_x = st3m_gfx_blit_x;
+    if (blit_y) *blit_y = st3m_gfx_blit_y;
+}

components/st3m/st3m_gfx.h

@@ -43,10 +43,10 @@ typedef enum {
     st3m_gfx_1bpp = 1,
     st3m_gfx_2bpp = 2,
     st3m_gfx_4bpp = 4,
-    st3m_gfx_8bpp = 8,
-    st3m_gfx_rgb332 = 9,
-    st3m_gfx_sepia = 10,
-    st3m_gfx_cool = 11,
+    st3m_gfx_8bpp = 8,    // bare 8bpp mode is grayscale
+    st3m_gfx_rgb332 = 9,  // variant of 8bpp mode using RGB
+    st3m_gfx_sepia = 10,  // grayscale rendering with sepia palette
+    st3m_gfx_cool = 11,   // grayscale rendering with cool palette
     st3m_gfx_palette = 15,
     // 16bpp modes have the lowest blit overhead - no osd for now
     st3m_gfx_16bpp = 16,
@@ -136,3 +136,15 @@ void st3m_gfx_splash(const char *text);
 // Draw the flow3r multi-coloured logo at coordinates x,y and with given
 // dimension (approx. bounding box size).
 void st3m_gfx_flow3r_logo(Ctx *ctx, float x, float y, float dim);
+
+// configure virtual viewport, the default values are 0, 0, 240, 240 which
+// also gives room for a copy of the fb for separate rasterize/blit in 16bpp
+//
+// with, height: width and height of virtual framebuffer
+//
+// changing the viewport should be done after setting the graphics mode - upon
+// graphics mode setting viewport is reset to 240, 240, 0,0,0,0
+void st3m_gfx_fbconfig(int width, int height, int blit_x, int blit_y);
+
+// get fbconfig values, arguments passed NULL ptrs are ignored.
+void st3m_gfx_get_fbconfig(int *width, int *height, int *blit_x, int *blit_y);

python_payload/st3m/run.py

@@ -75,6 +75,7 @@ class ApplicationMenu(SimpleMenu):
         # set the default graphics mode, this is a no-op if
         # it is already set
         sys_display.set_mode(0)
+        sys_display.fbconfig(240, 240, 0, 0)
         leds.set_slew_rate(100)
         leds.set_gamma(1.0, 1.0, 1.0)
         leds.set_auto_update(False)

sdkconfig.defaults

@@ -10,7 +10,7 @@ CONFIG_ESPTOOLPY_AFTER="hard_reset"
 CONFIG_PARTITION_TABLE_CUSTOM=y
 CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
 CONFIG_COMPILER_OPTIMIZATION_PERF=y
-CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT=y
+CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=y
 CONFIG_BT_ENABLED=y
 CONFIG_BT_NIMBLE_ENABLED=y
 CONFIG_BT_NIMBLE_MAX_CONNECTIONS=4
@@ -50,3 +50,11 @@ CONFIG_LWIP_MULTICAST_PING=y
 CONFIG_LWIP_BROADCAST_PING=y
 # CONFIG_ESP_WIFI_IRAM_OPT is not set
 # CONFIG_ESP_WIFI_RX_IRAM_OPT is not set
+CONFIG_COMPILER_STACK_CHECK_MODE_STRONG=y
+CONFIG_HEAP_POISONING_COMPREHENSIVE=y
+CONFIG_HEAP_TASK_TRACKING=y
+# CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT is not set
+CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y
+CONFIG_DEBUG_GDB_ENABLED=y
+CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y
+CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK=y