Merge remote-tracking branch 'origin/main'

Author: weblate

shared-module/busdisplay/BusDisplay.c

@@ -233,6 +233,7 @@ static bool _refresh_area(busdisplay_busdisplay_obj_t *self, const displayio_are
         return true;
     }
     uint16_t rows_per_buffer = displayio_area_height(&clipped);
+    uint16_t cols_per_buffer = displayio_area_width(&clipped);
     uint8_t pixels_per_word = (sizeof(uint32_t) * 8) / self->core.colorspace.depth;
     uint16_t pixels_per_buffer = displayio_area_size(&clipped);
 
@@ -243,26 +244,29 @@ static bool _refresh_area(busdisplay_busdisplay_obj_t *self, const displayio_are
         subrectangles = rows_per_buffer / 8;  // page addressing mode writes 8 rows at a time
         rows_per_buffer = 8;
     } else if (displayio_area_size(&clipped) > buffer_size * pixels_per_word) {
-        rows_per_buffer = buffer_size * pixels_per_word / displayio_area_width(&clipped);
-        if (rows_per_buffer == 0) {
-            rows_per_buffer = 1;
-        }
-        // If pixels are packed by column then ensure rows_per_buffer is on a byte boundary.
-        if (self->core.colorspace.depth < 8 && !self->core.colorspace.pixels_in_byte_share_row) {
-            uint8_t pixels_per_byte = 8 / self->core.colorspace.depth;
-            if (rows_per_buffer % pixels_per_byte != 0) {
-                rows_per_buffer -= rows_per_buffer % pixels_per_byte;
+        uint16_t buffer_pixels = buffer_size * pixels_per_word;
+        if (self->core.transform.transpose_xy && self->core.colorspace.depth >= 8) {
+            // Rotated 90 or 270: a panel column is a source row. Send bands of columns so sources
+            // are read along their rows, which OnDiskBitmap needs to avoid a file seek per pixel.
+            rows_per_buffer = MIN(rows_per_buffer, buffer_pixels);
+            cols_per_buffer = buffer_pixels / rows_per_buffer;
+        } else {
+            rows_per_buffer = buffer_pixels / cols_per_buffer;
+            if (rows_per_buffer == 0) {
+                rows_per_buffer = 1;
+            }
+            // If pixels are packed by column then ensure rows_per_buffer is on a byte boundary.
+            if (self->core.colorspace.depth < 8 && !self->core.colorspace.pixels_in_byte_share_row) {
+                uint8_t pixels_per_byte = 8 / self->core.colorspace.depth;
+                if (rows_per_buffer % pixels_per_byte != 0) {
+                    rows_per_buffer -= rows_per_buffer % pixels_per_byte;
+                }
             }
         }
-        subrectangles = displayio_area_height(&clipped) / rows_per_buffer;
-        if (displayio_area_height(&clipped) % rows_per_buffer != 0) {
-            subrectangles++;
-        }
-        pixels_per_buffer = rows_per_buffer * displayio_area_width(&clipped);
-        buffer_size = pixels_per_buffer / pixels_per_word;
-        if (pixels_per_buffer % pixels_per_word) {
-            buffer_size += 1;
-        }
+        subrectangles = ((displayio_area_height(&clipped) + rows_per_buffer - 1) / rows_per_buffer) *
+            ((displayio_area_width(&clipped) + cols_per_buffer - 1) / cols_per_buffer);
+        pixels_per_buffer = rows_per_buffer * cols_per_buffer;
+        buffer_size = (pixels_per_buffer + pixels_per_word - 1) / pixels_per_word;
     }
 
     // Allocated and shared as a uint32_t array so the compiler knows the
@@ -271,19 +275,17 @@ static bool _refresh_area(busdisplay_busdisplay_obj_t *self, const displayio_are
     uint32_t buffer[buffer_size];
     uint32_t mask[mask_length];
 
-    uint16_t remaining_rows = displayio_area_height(&clipped);
+    displayio_area_t subrectangle = clipped;
+    subrectangle.next = NULL;
 
     for (uint16_t j = 0; j < subrectangles; j++) {
-        displayio_area_t subrectangle = {
-            .x1 = clipped.x1,
-            .y1 = clipped.y1 + rows_per_buffer * j,
-            .x2 = clipped.x2,
-            .y2 = clipped.y1 + rows_per_buffer * (j + 1)
-        };
-        if (remaining_rows < rows_per_buffer) {
-            subrectangle.y2 = subrectangle.y1 + remaining_rows;
+        // Down the rows of a band first, then to the next band of columns.
+        if (subrectangle.y1 >= clipped.y2) {
+            subrectangle.y1 = clipped.y1;
+            subrectangle.x1 += cols_per_buffer;
         }
-        remaining_rows -= rows_per_buffer;
+        subrectangle.x2 = MIN(subrectangle.x1 + cols_per_buffer, clipped.x2);
+        subrectangle.y2 = MIN(subrectangle.y1 + rows_per_buffer, clipped.y2);
 
         uint16_t subrectangle_size_bytes;
         if (self->core.colorspace.depth >= 8) {
@@ -305,6 +307,7 @@ static bool _refresh_area(busdisplay_busdisplay_obj_t *self, const displayio_are
         }
         _send_pixels(self, (uint8_t *)buffer, subrectangle_size_bytes);
         displayio_display_bus_end_transaction(&self->bus);
+        subrectangle.y1 = subrectangle.y2;
 
         // Run background tasks so they can run during an explicit refresh.
         // Auto-refresh won't run background tasks here because it is a background task itself.

shared-module/displayio/OnDiskBitmap.c

@@ -28,6 +28,7 @@ static uint32_t read_word(uint16_t *bmp_header, uint16_t index) {
 
 void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, mp_obj_t file) {
     self->file = file;
+    self->cache_len = 0;
     uint16_t bmp_header[69];
     int errcode = 0;
 
@@ -182,43 +183,47 @@ uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *s
     } else {
         location = self->data_offset + (self->height - y - 1) * self->stride + x / pixels_per_byte;
     }
-    // We don't cache here because the underlying FS caches sectors.
     int errcode = 0;
-    mp_stream_seek(self->file, location, MP_SEEK_SET, &errcode);
-    if (errcode != 0) {
-        return 0;
+    if (location < self->cache_start || location + bytes_per_pixel > self->cache_start + self->cache_len) {
+        mp_stream_seek(self->file, location, MP_SEEK_SET, &errcode);
+        if (errcode != 0) {
+            return 0;
+        }
+        self->cache_start = location;
+        self->cache_len = mp_stream_rw(self->file, self->cache, sizeof(self->cache), &errcode, MP_STREAM_RW_ONCE);
+        if (errcode != 0 || self->cache_len < bytes_per_pixel) {
+            self->cache_len = 0;
+            return 0;
+        }
     }
     uint32_t pixel_data = 0;
-    mp_stream_rw(self->file, &pixel_data, bytes_per_pixel, &errcode, MP_STREAM_RW_ONCE);
-    if (errcode == 0) {
-        uint32_t tmp = 0;
-        uint8_t red;
-        uint8_t green;
-        uint8_t blue;
-        if (bytes_per_pixel == 1) {
-            uint8_t offset = (x % pixels_per_byte) * self->bits_per_pixel;
-            uint8_t mask = (1 << self->bits_per_pixel) - 1;
-
-            return (pixel_data >> ((8 - self->bits_per_pixel) - offset)) & mask;
-        } else if (bytes_per_pixel == 2) {
-            if (self->g_bitmask == 0x07e0) { // 565
-                red = ((pixel_data & self->r_bitmask) >> 11);
-                green = ((pixel_data & self->g_bitmask) >> 5);
-                blue = ((pixel_data & self->b_bitmask) >> 0);
-            } else { // 555
-                red = ((pixel_data & self->r_bitmask) >> 10);
-                green = ((pixel_data & self->g_bitmask) >> 4);
-                blue = ((pixel_data & self->b_bitmask) >> 0);
-            }
-            tmp = (red << 19 | green << 10 | blue << 3);
-            return tmp;
-        } else if ((bytes_per_pixel == 4) && (self->bitfield_compressed)) {
-            return pixel_data & 0x00FFFFFF;
-        } else {
-            return pixel_data;
+    memcpy(&pixel_data, self->cache + (location - self->cache_start), bytes_per_pixel);
+    uint32_t tmp = 0;
+    uint8_t red;
+    uint8_t green;
+    uint8_t blue;
+    if (bytes_per_pixel == 1) {
+        uint8_t offset = (x % pixels_per_byte) * self->bits_per_pixel;
+        uint8_t mask = (1 << self->bits_per_pixel) - 1;
+
+        return (pixel_data >> ((8 - self->bits_per_pixel) - offset)) & mask;
+    } else if (bytes_per_pixel == 2) {
+        if (self->g_bitmask == 0x07e0) { // 565
+            red = ((pixel_data & self->r_bitmask) >> 11);
+            green = ((pixel_data & self->g_bitmask) >> 5);
+            blue = ((pixel_data & self->b_bitmask) >> 0);
+        } else { // 555
+            red = ((pixel_data & self->r_bitmask) >> 10);
+            green = ((pixel_data & self->g_bitmask) >> 4);
+            blue = ((pixel_data & self->b_bitmask) >> 0);
         }
+        tmp = (red << 19 | green << 10 | blue << 3);
+        return tmp;
+    } else if ((bytes_per_pixel == 4) && (self->bitfield_compressed)) {
+        return pixel_data & 0x00FFFFFF;
+    } else {
+        return pixel_data;
     }
-    return 0;
 }
 
 uint16_t common_hal_displayio_ondiskbitmap_get_height(displayio_ondiskbitmap_t *self) {

shared-module/displayio/OnDiskBitmap.h

@@ -28,4 +28,8 @@ typedef struct {
     };
     bool bitfield_compressed;
     uint8_t bits_per_pixel;
+    // The last bytes read from the file. Pixels are read along rows, so most reads hit it.
+    uint8_t cache_len;
+    uint32_t cache_start;
+    uint8_t cache[64];
 } displayio_ondiskbitmap_t;