Merge branch 's-direct' into s-opaque

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

esphome/components/online_image/online_image.cpp

@@ -231,30 +231,47 @@ void OnlineImage::loop() {
       this->end_connection_();
       this->download_error_callback_.call();
       return;
-    } else if (this->downloader_->is_read_complete()) {
-      // The response has ended, so data left in the buffer can never be completed
-      size_t unread = this->download_buffer_.unread();
-      if (unread == 0 && this->downloader_->get_bytes_read() > 0) {
-        // A decoder that counts pixels knows the image was cut off; PNG cannot tell, so it passes
-        if (this->is_decode_finished() || !this->decoder_knows_end()) {
-          this->finish_download_();
+    } else {
+      // Nothing new arrived. The decoder works for a limited time per call, so it may still have data to use.
+      if (this->download_buffer_.unread() != 0) {
+        auto consumed = this->feed_data(this->download_buffer_.data(), this->download_buffer_.unread());
+        if (consumed < 0) {
+          ESP_LOGE(TAG, "Error decoding image: %s", esphome::runtime_image::decode_error_to_string(consumed));
+          this->end_connection_();
+          this->download_error_callback_.call();
+          return;
+        }
+        if (consumed > 0) {
+          this->download_buffer_.read(consumed);
+          this->last_data_time_ = App.get_loop_component_start_time();
           return;
         }
-        ESP_LOGE(TAG, "Download ended before the image was complete");
-      } else if (unread == 0) {
-        ESP_LOGE(TAG, "Server sent an empty response");
-      } else {
-        ESP_LOGE(TAG, "Download ended with %zu bytes the decoder could not use", unread);
       }
-      this->end_connection_();
-      this->download_error_callback_.call();
-      return;
-    } else if (App.get_loop_component_start_time() - this->last_data_time_ >= this->parent_->get_timeout()) {
-      // ESP-IDF keeps returning 0 after the server closes the connection early
-      ESP_LOGE(TAG, "No data received for %" PRIu32 " ms", this->parent_->get_timeout());
-      this->end_connection_();
-      this->download_error_callback_.call();
-      return;
+      if (this->downloader_->is_read_complete()) {
+        // The response has ended, so data left in the buffer can never be completed
+        size_t unread = this->download_buffer_.unread();
+        if (unread == 0 && this->downloader_->get_bytes_read() > 0) {
+          // A decoder that counts pixels knows the image was cut off; PNG cannot tell, so it passes
+          if (this->is_decode_finished() || !this->decoder_knows_end()) {
+            this->finish_download_();
+            return;
+          }
+          ESP_LOGE(TAG, "Download ended before the image was complete");
+        } else if (unread == 0) {
+          ESP_LOGE(TAG, "Server sent an empty response");
+        } else {
+          ESP_LOGE(TAG, "Download ended with %zu bytes the decoder could not use", unread);
+        }
+        this->end_connection_();
+        this->download_error_callback_.call();
+        return;
+      } else if (App.get_loop_component_start_time() - this->last_data_time_ >= this->parent_->get_timeout()) {
+        // ESP-IDF keeps returning 0 after the server closes the connection early
+        ESP_LOGE(TAG, "No data received for %" PRIu32 " ms", this->parent_->get_timeout());
+        this->end_connection_();
+        this->download_error_callback_.call();
+        return;
+      }
     }
   } else {
     // Buffer is full, need to decode some data first

esphome/components/runtime_image/bmp_decoder.cpp

@@ -3,6 +3,7 @@
 #ifdef USE_RUNTIME_IMAGE_BMP
 
 #include "esphome/components/display/display.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -12,6 +13,9 @@ namespace esphome::runtime_image {
 
 ESPHOME_LOG_TAG(TAG, "image_decoder.bmp");
 
+// BMP has no alpha. Every pixel is drawn opaque, or a transparent image would hide it
+static constexpr Color OPAQUE_BLACK(0, 0, 0, 0xFF);
+
 void BmpDecoder::reset() {
   ImageDecoder::reset();
   this->bits_per_pixel_ = 0;
@@ -142,23 +146,31 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
     this->current_index_ = this->data_offset_;
     index = this->data_offset_;
   }
+  // A call that has run for DECODE_TIME_LIMIT_MS stops, and the caller passes the rest again later
+  const uint32_t start = millis();
+  uint32_t steps = 0;
+  auto out_of_time = [start, &steps]() {
+    return ++steps % DECODE_TIME_CHECK_STEPS == 0 && millis() - start >= DECODE_TIME_LIMIT_MS;
+  };
+  // Bytes after the last pixel are used up without drawing anything
+  const size_t total_pixels = static_cast<size_t>(this->width_) * this->height_;
   switch (this->bits_per_pixel_) {
     case 1: {
       size_t width = static_cast<size_t>(this->width_);
-      while (index < size) {
+      while (index < size && this->paint_index_ < total_pixels) {
         size_t x = this->paint_index_ % width;
         size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / width);
         size_t remaining_in_row = width - x;
         uint8_t pixels_in_byte = std::min<size_t>(remaining_in_row, 8);
         bool end_of_row = remaining_in_row <= 8;
         size_t needed = 1 + (end_of_row ? this->padding_bytes_ : 0);
-        if (index + needed > size) {
+        if (index + needed > size || out_of_time()) {
           this->decoded_bytes_ += index;
           return index;
         }
         uint8_t current_byte = buffer[index];
         for (uint8_t i = 0; i < pixels_in_byte; i++) {
-          Color c = (current_byte & (1 << (7 - i))) ? display::COLOR_ON : display::COLOR_OFF;
+          Color c = (current_byte & (1 << (7 - i))) ? display::COLOR_ON : OPAQUE_BLACK;
           this->draw(x + i, y, 1, 1, c);
         }
         this->paint_index_ += pixels_in_byte;
@@ -175,11 +187,11 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
     case 8: {
       size_t width = static_cast<size_t>(this->width_);
       size_t last_col = width - 1;
-      while (index < size) {
+      while (index < size && this->paint_index_ < total_pixels) {
         size_t x = this->paint_index_ % width;
         size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / width);
         size_t needed = 1 + ((x == last_col) ? this->padding_bytes_ : 0);
-        if (index + needed > size) {
+        if (index + needed > size || out_of_time()) {
           this->decoded_bytes_ += index;
           return index;
         }
@@ -194,7 +206,7 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
         uint8_t b = rgb & 0xff;
         uint8_t g = (rgb >> 8) & 0xff;
         uint8_t r = (rgb >> 16) & 0xff;
-        this->draw(x, y, 1, 1, Color(r, g, b));
+        this->draw(x, y, 1, 1, Color(r, g, b, 0xFF));
         this->paint_index_++;
         this->current_index_++;
         index++;
@@ -208,18 +220,18 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
     case 24: {
       size_t width = static_cast<size_t>(this->width_);
       size_t last_col = width - 1;
-      while (index < size) {
+      while (index < size && this->paint_index_ < total_pixels) {
         size_t x = this->paint_index_ % width;
         size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / width);
         size_t needed = 3 + ((x == last_col) ? this->padding_bytes_ : 0);
-        if (index + needed > size) {
+        if (index + needed > size || out_of_time()) {
           this->decoded_bytes_ += index;
           return index;
         }
         uint8_t b = buffer[index];
         uint8_t g = buffer[index + 1];
         uint8_t r = buffer[index + 2];
-        this->draw(x, y, 1, 1, Color(r, g, b));
+        this->draw(x, y, 1, 1, Color(r, g, b, 0xFF));
         this->paint_index_++;
         this->current_index_ += 3;
         index += 3;

esphome/components/runtime_image/image_decoder.cpp

@@ -1,5 +1,6 @@
 #include "image_decoder.h"
 #include "runtime_image.h"
+#include "esphome/components/display/display_color_utils.h"
 #include "esphome/core/log.h"
 #include <algorithm>
 
@@ -8,17 +9,80 @@ namespace esphome::runtime_image {
 ESPHOME_LOG_TAG(TAG, "image_decoder");
 
 bool ImageDecoder::set_size(int width, int height) {
-  bool success = this->image_->resize(width, height) > 0;
-  this->size_valid_ = success;
+  if (!this->resize_image_(width, height))
+    return false;
+  this->prepare_draw_(width, height);
+  return true;
+}
+
+bool ImageDecoder::resize_image_(int width, int height) {
+  this->size_valid_ = this->image_->resize(width, height) > 0;
+  return this->size_valid_;
+}
+
+void ImageDecoder::prepare_draw_(int width, int height) {
   this->draw_width_ = width;
   this->draw_height_ = height;
-  return success;
+  this->direct_rgb565_ = this->image_->get_type() == image::IMAGE_TYPE_RGB565 && !this->image_->has_transparency();
+  if (!this->direct_rgb565_)
+    return;
+  if ((this->x_boundaries_.capacity() < static_cast<size_t>(width + 1) && !this->x_boundaries_.try_init(width + 1)) ||
+      (this->y_boundaries_.capacity() < static_cast<size_t>(height + 1) && !this->y_boundaries_.try_init(height + 1))) {
+    ESP_LOGW(TAG, "No memory to draw straight into the buffer; drawing pixel by pixel");
+    this->direct_rgb565_ = false;
+    // Free the table that did fit, as nothing uses it
+    this->x_boundaries_ = FixedVector<uint16_t>();
+    this->y_boundaries_ = FixedVector<uint16_t>();
+    return;
+  }
+  this->x_boundaries_.clear();
+  this->y_boundaries_.clear();
+  const int buffer_width = this->image_->get_buffer_width();
+  const int buffer_height = this->image_->get_buffer_height();
+  // The same boundaries as draw() uses, so both paths paint the same pixels
+  for (int x = 0; x <= width; x++) {
+    this->x_boundaries_.push_back(static_cast<uint16_t>(scale_boundary(x, width, buffer_width)));
+  }
+  for (int y = 0; y <= height; y++) {
+    this->y_boundaries_.push_back(static_cast<uint16_t>(scale_boundary(y, height, buffer_height)));
+  }
+}
+
+void ImageDecoder::draw_rgb565_(int x, int y, int w, int h, uint16_t rgb565) {
+  const int x_end = std::min(x + w, this->draw_width_);
+  const int y_end = std::min(y + h, this->draw_height_);
+  x = std::max(x, 0);
+  y = std::max(y, 0);
+  if (x >= x_end || y >= y_end)
+    return;
+  // A block of source pixels lands on one block of the buffer
+  const uint16_t x1 = this->x_boundaries_[x];
+  const uint16_t x2 = this->x_boundaries_[x_end];
+  const uint16_t y1 = this->y_boundaries_[y];
+  const uint16_t y2 = this->y_boundaries_[y_end];
+  const bool big_endian = this->image_is_big_endian_();
+  const uint8_t first = big_endian ? rgb565 >> 8 : rgb565 & 0xFF;
+  const uint8_t second = big_endian ? rgb565 & 0xFF : rgb565 >> 8;
+  uint8_t *const buffer = this->image_buffer_();
+  const uint32_t buffer_width = this->image_->get_buffer_width();
+  for (uint32_t row = y1; row < y2; row++) {
+    uint8_t *destination = buffer + (row * buffer_width + x1) * 2;
+    for (uint32_t col = x1; col < x2; col++) {
+      destination[0] = first;
+      destination[1] = second;
+      destination += 2;
+    }
+  }
 }
 
 void ImageDecoder::draw(int x, int y, int w, int h, const Color &color) {
   if (!this->size_valid_) {
     return;
   }
+  if (this->direct_rgb565_) {
+    this->draw_rgb565_(x, y, w, h, display::ColorUtil::color_to_565(color));
+    return;
+  }
   // When shrinking, each target pixel is painted once, by the first source pixel that reaches it, rather than by every
   // pixel that lands on it. Integer maths: the S3 has no double FPU.
   const int buffer_width = this->image_->get_buffer_width();

esphome/components/runtime_image/image_decoder.h

@@ -2,6 +2,7 @@
 #include <cstdint>
 
 #include "esphome/core/color.h"
+#include "esphome/core/helpers.h"
 #include "image_format.h"
 
 namespace esphome::runtime_image {
@@ -47,6 +48,11 @@ constexpr const char *decode_error_to_string(int error) {
   }
 }
 
+// The longest one decode() call works before it returns, leaving the rest of the data for the next call
+static constexpr uint32_t DECODE_TIME_LIMIT_MS = 15;
+// Pixel loops read the clock once per this many steps
+static constexpr uint32_t DECODE_TIME_CHECK_STEPS = 64;
+
 class RuntimeImage;
 
 /// Input that a decoder reads itself as it goes, so the whole image never has to be in memory at once
@@ -94,6 +100,7 @@ class ImageDecoder {
     this->size_valid_ = true;
     this->draw_width_ = 0;
     this->draw_height_ = 0;
+    this->direct_rgb565_ = false;
   }
 
   /**
@@ -188,7 +195,20 @@ class ImageDecoder {
   /// Whether is_finished() can tell a complete image from a cut-off one
   virtual bool knows_end() const { return this->expected_size_ > 0; }
 
+  /// The image is opaque RGB565, so draw() writes it straight into the buffer
+  bool uses_direct_rgb565() const { return this->direct_rgb565_; }
+
  protected:
+  /// Resize the image for a width x height source, without preparing to draw. prepare_draw_() must follow.
+  bool resize_image_(int width, int height);
+  /**
+   * Draw a source of width x height over the whole buffer from now on. For an opaque RGB565 image this builds the
+   * tables of where each source column and row lands; without the memory for them it draws pixel by pixel instead.
+   */
+  void prepare_draw_(int width, int height);
+  /// Paint a block of source pixels in one color straight into the buffer. Only while uses_direct_rgb565().
+  void draw_rgb565_(int x, int y, int w, int h, uint16_t rgb565);
+
   /// The image's pixel buffer, for decoders that write their output straight into it
   uint8_t *image_buffer_() const;
   bool image_is_big_endian_() const;
@@ -196,12 +216,16 @@ class ImageDecoder {
   // Size of the image as the decoder draws it, which draw() spreads over the buffer
   int draw_width_ = 0;
   int draw_height_ = 0;
+  // Boundary n is the first buffer column, or row, that source column, or row, n paints
+  FixedVector<uint16_t> x_boundaries_{};
+  FixedVector<uint16_t> y_boundaries_{};
   RuntimeImage *image_;
   size_t expected_size_ = 0;  // Expected data size (0 if unknown)
   size_t decoded_bytes_ = 0;  // Bytes processed so far
   const ImageFormat format_;
   bool active_ = false;     // A decoding session is in progress
   bool size_valid_ = true;  // Last set_size() result; draw() no-ops while false
+  bool direct_rgb565_ = false;
 };
 
 }  // namespace esphome::runtime_image

esphome/components/runtime_image/jpeg_decoder.cpp

@@ -16,30 +16,6 @@ ESPHOME_LOG_TAG(TAG, "image_decoder.jpeg");
 
 namespace esphome::runtime_image {
 
-bool JpegDecoder::prepare_rgb565_scaling_(int width, int height) {
-  if (this->x_boundaries_.capacity() < static_cast<size_t>(width + 1) && !this->x_boundaries_.try_init(width + 1)) {
-    return false;
-  }
-  if (this->y_boundaries_.capacity() < static_cast<size_t>(height + 1) && !this->y_boundaries_.try_init(height + 1)) {
-    return false;
-  }
-
-  this->source_width_ = width;
-  this->source_height_ = height;
-  this->x_boundaries_.clear();
-  this->y_boundaries_.clear();
-  const int target_width = this->image_->get_buffer_width();
-  const int target_height = this->image_->get_buffer_height();
-  // The same boundaries as the generic draw() path, so an 8 to 4 scale keeps columns 0, 2, 4 and 6 in both
-  for (int x = 0; x <= width; x++) {
-    this->x_boundaries_.push_back(static_cast<uint16_t>(scale_boundary(x, width, target_width)));
-  }
-  for (int y = 0; y <= height; y++) {
-    this->y_boundaries_.push_back(static_cast<uint16_t>(scale_boundary(y, height, target_height)));
-  }
-  return true;
-}
-
 void JpegDecoder::draw_rgb565(int x, int y, int w, int h, const uint8_t *pixels) {
   if (pixels == nullptr) {
     return;
@@ -50,14 +26,14 @@ void JpegDecoder::draw_rgb565(int x, int y, int w, int h, const uint8_t *pixels)
   const uint8_t first = this->image_is_big_endian_() ? 1 : 0;
   for (int source_y = 0; source_y < h; source_y++) {
     const int absolute_y = y + source_y;
-    if (absolute_y < 0 || absolute_y >= this->source_height_) {
+    if (absolute_y < 0 || absolute_y >= this->draw_height_) {
       continue;
     }
     const uint16_t y1 = this->y_boundaries_[absolute_y];
     const uint16_t y2 = this->y_boundaries_[absolute_y + 1];
     for (int source_x = 0; source_x < w; source_x++) {
       const int absolute_x = x + source_x;
-      if (absolute_x < 0 || absolute_x >= this->source_width_) {
+      if (absolute_x < 0 || absolute_x >= this->draw_width_) {
         continue;
       }
       const uint16_t x1 = this->x_boundaries_[absolute_x];
@@ -155,17 +131,10 @@ int JpegDecoder::start_() {
   ESP_LOGD(TAG, "Image size: %d x %d, bpp: %d", this->jpeg_.getWidth(), this->jpeg_.getHeight(), this->jpeg_.getBpp());
 
   this->jpeg_.setUserPointer(this);
-  this->direct_rgb565_ = this->image_->get_type() == image::IMAGE_TYPE_RGB565 && !this->image_->has_transparency();
-  if (this->direct_rgb565_) {
-    // JPEGDEC's RGB565_BIG_ENDIAN output is not byte swapped on every build (the x86 host build
-    // returns little-endian words for it), so the byte order is applied in draw_rgb565 instead
-    this->jpeg_.setPixelType(RGB565_LITTLE_ENDIAN);
-  } else {
-    this->jpeg_.setPixelType(RGB8888);
-  }
   const int width = this->jpeg_.getWidth();
   const int height = this->jpeg_.getHeight();
-  if (!this->set_size(width, height)) {
+  // The tables for drawing are only built once the decoded size is known, below
+  if (!this->resize_image_(width, height)) {
     return DECODE_ERROR_OUT_OF_MEMORY;
   }
   // JPEGDEC can decode at 1/2, 1/4 or 1/8 size for much less work. Use the smallest size that still has at least as
@@ -179,13 +148,16 @@ int JpegDecoder::start_() {
   }
   const int decoded_width = (width + this->scale_ - 1) / this->scale_;
   const int decoded_height = (height + this->scale_ - 1) / this->scale_;
-  this->draw_width_ = decoded_width;
-  this->draw_height_ = decoded_height;
   if (this->scale_ != 1) {
     ESP_LOGD(TAG, "Decoding at 1/%d size, %d x %d", this->scale_, decoded_width, decoded_height);
   }
-  if (this->direct_rgb565_ && !this->prepare_rgb565_scaling_(decoded_width, decoded_height)) {
-    return DECODE_ERROR_OUT_OF_MEMORY;
+  this->prepare_draw_(decoded_width, decoded_height);
+  if (this->direct_rgb565_) {
+    // JPEGDEC's RGB565_BIG_ENDIAN output is not byte swapped on every build (the x86 host build
+    // returns little-endian words for it), so the byte order is applied in draw_rgb565 instead
+    this->jpeg_.setPixelType(RGB565_LITTLE_ENDIAN);
+  } else {
+    this->jpeg_.setPixelType(RGB8888);
   }
   return 0;
 }

esphome/components/runtime_image/jpeg_decoder.h

@@ -30,13 +30,11 @@ class JpegDecoder : public ImageDecoder {
   /// Decodes one row of MCUs (8 or 16 pixel rows), or waits part way through one for more of the source
   int HOT decode_step() override;
 
-  bool uses_direct_rgb565() const { return this->direct_rgb565_; }
   /// JPEGDEC decodes the image at 1/get_scale() of its size: 1, 2, 4 or 8
   int get_scale() const { return this->scale_; }
   void draw_rgb565(int x, int y, int w, int h, const uint8_t *pixels);
 
  protected:
-  bool prepare_rgb565_scaling_(int width, int height);
   /// Set up an opened image for decoding. Returns 0, or a DecodeError.
   int start_();
   /// The JPEGDEC option for scale_: JPEG_SCALE_HALF, _QUARTER and _EIGHTH are the divisors themselves
@@ -49,13 +47,8 @@ class JpegDecoder : public ImageDecoder {
   static void source_close(void *handle) {}
 
   JPEGDEC jpeg_{};
-  FixedVector<uint16_t> x_boundaries_{};
-  FixedVector<uint16_t> y_boundaries_{};
-  int source_width_{0};
-  int source_height_{0};
   int scale_{1};                   // JPEGDEC decodes at 1/scale_ of the image size
   DecodeSource *source_{nullptr};  // Set while a begin_source() decode is in progress
-  bool direct_rgb565_{false};
   bool source_failed_{false};
 };
 

esphome/components/runtime_image/png_decoder.cpp

@@ -6,10 +6,15 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+#include <algorithm>
+
 ESPHOME_LOG_TAG(TAG, "image_decoder.png");
 
 namespace esphome::runtime_image {
 
+// Compressed bytes handed to pngle at a time
+static constexpr size_t FEED_PIECE_SIZE = 64;
+
 /**
  * @brief Callback method that will be called by the PNGLE engine when the basic
  * data of the image is received (i.e. width and height);
@@ -93,16 +98,26 @@ int HOT PngDecoder::decode(uint8_t *buffer, size_t size) {
     ESP_LOGD(TAG, "Waiting for more data");
     return 0;
   }
-  auto fed = pngle_feed(this->pngle_, buffer, size);
-  if (fed < 0) {
-    ESP_LOGE(TAG, "Error decoding image: %s", pngle_error(this->pngle_));
-    return DECODE_ERROR_INTERNAL_DECODER_ERROR;
-  } else if (!this->size_valid_) {
-    return DECODE_ERROR_OUT_OF_MEMORY;
-  } else {
+  // A few compressed bytes can hold many rows of pixels, so feed small pieces and stop once the call has run for
+  // DECODE_TIME_LIMIT_MS; the caller passes the rest again later
+  const uint32_t start = millis();
+  size_t total = 0;
+  while (total < size) {
+    const size_t piece = std::min(FEED_PIECE_SIZE, size - total);
+    const int fed = pngle_feed(this->pngle_, buffer + total, piece);
+    if (fed < 0) {
+      ESP_LOGE(TAG, "Error decoding image: %s", pngle_error(this->pngle_));
+      return DECODE_ERROR_INTERNAL_DECODER_ERROR;
+    }
+    if (!this->size_valid_)
+      return DECODE_ERROR_OUT_OF_MEMORY;
     this->decoded_bytes_ += fed;
+    total += fed;
+    // pngle takes less than the piece when a chunk header or CRC runs past its end; that is no reason to stop
+    if (fed == 0 || millis() - start >= DECODE_TIME_LIMIT_MS)
+      break;
   }
-  return fed;
+  return total;
 }
 
 }  // namespace esphome::runtime_image

esphome/components/runtime_image/qoi_decoder.cpp

@@ -3,9 +3,11 @@
 #ifdef USE_RUNTIME_IMAGE_QOI
 
 #include "esphome/components/display/display.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+#include <algorithm>
 #include <cinttypes>
 
 namespace esphome::runtime_image {
@@ -102,12 +104,17 @@ int HOT QoiDecoder::decode(uint8_t *buffer, size_t size) {
 
   Color color;
   const size_t total_pixels = this->width_ * this->height_;
+  // A call that has run for DECODE_TIME_LIMIT_MS stops, and the caller passes the rest again later
+  const uint32_t start = millis();
+  uint32_t steps = 0;
   while (index < size && this->paint_index_ < total_pixels) {
+    if (++steps % DECODE_TIME_CHECK_STEPS == 0 && millis() - start >= DECODE_TIME_LIMIT_MS)
+      break;
     color = this->last_pixel_;
     uint8_t byte = buffer[index];
     if (byte == QOI_OP_RGB) {
       if (size < index + QOI_RGB_CHUNK_SIZE) {
-        return index;  // Need more data for RGB chunk
+        break;  // Need more data for RGB chunk
       }
       index++;
       color.r = buffer[index++];
@@ -117,7 +124,7 @@ int HOT QoiDecoder::decode(uint8_t *buffer, size_t size) {
       this->paint_index_++;
     } else if (byte == QOI_OP_RGBA) {
       if (size < index + QOI_RGBA_CHUNK_SIZE) {
-        return index;  // Need more data for RGBA chunk
+        break;  // Need more data for RGBA chunk
       }
       index++;
       color.r = buffer[index++];
@@ -129,15 +136,18 @@ int HOT QoiDecoder::decode(uint8_t *buffer, size_t size) {
     } else if ((byte & QOI_MASK_OP) == QOI_OP_RUN) {
       // QOI run chunk
       size_t run_length = (byte & QOI_MASK_VALUE) + 1;  // run length is encoded in the lower 6 bits, plus one
-      for (size_t i = 0; i < run_length; i++) {
-        // TODO: optimize by drawing runs of pixels at once instead of one by one
-        this->draw(this->paint_index_ % this->width_, this->paint_index_ / this->width_, 1, 1, color);
-        this->paint_index_++;
+      // Draw the part of the run in each row it covers at once
+      while (run_length > 0) {
+        const size_t x = this->paint_index_ % this->width_;
+        const size_t count = std::min(run_length, this->width_ - x);
+        this->draw(x, this->paint_index_ / this->width_, count, 1, color);
+        this->paint_index_ += count;
+        run_length -= count;
       }
       index++;
     } else if ((byte & QOI_MASK_OP) == QOI_OP_LUMA) {
       if (size < index + QOI_LUMA_CHUNK_SIZE) {
-        return index;  // Need more data for LUMA chunk
+        break;  // Need more data for LUMA chunk
       }
       index++;
       uint8_t byte2 = buffer[index++];
@@ -165,8 +175,10 @@ int HOT QoiDecoder::decode(uint8_t *buffer, size_t size) {
     this->last_pixel_ = color;
     this->color_table_[qoi_color_table_index(color)] = color;
   }
-  this->decoded_bytes_ += size;
-  return size;
+  if (this->paint_index_ >= total_pixels)
+    index = size;  // All that follows the last pixel is the end marker
+  this->decoded_bytes_ += index;
+  return index;
 }
 
 }  // namespace esphome::runtime_image

esphome/components/runtime_image/runtime_image.cpp

@@ -116,7 +116,9 @@ void RuntimeImage::draw_pixel(int x, int y, const Color &color) {
     }
     case image::IMAGE_TYPE_GRAYSCALE: {
       uint32_t pos = this->get_position_(x, y);
-      auto gray = static_cast<uint8_t>(0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b);
+      // 0.2125, 0.7154 and 0.0721 in 1/256ths, summing to 256 so white stays 255. Integer maths: the S3 has no
+      // double FPU
+      auto gray = static_cast<uint8_t>((54 * color.r + 183 * color.g + 19 * color.b) >> 8);
       if (this->transparency_ == image::TRANSPARENCY_CHROMA_KEY) {
         if (gray == 1) {
           gray = 0;

tests/components/online_image/test_download_end.cpp

@@ -12,8 +12,10 @@
 
 #include "esphome/components/http_request/http_request.h"
 #include "esphome/components/online_image/online_image.h"
+#include "esphome/components/runtime_image/png_decoder.h"
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
+#include "pngle.h"
 
 namespace esphome::online_image::testing {
 
@@ -135,6 +137,153 @@ static constexpr std::array<uint8_t, 69> PNG_1X1{
     0x0C, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0xF8, 0xCF, 0xC0, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0xC9,
     0xFE, 0x92, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82};
 
+// 800x600 RGB PNG of a single color, 2312 bytes: the decoder needs several calls to draw it.
+// The same bytes are in tests/components/runtime_image/test_png_time_limit.cpp.
+static const uint8_t PNG_SOLID[] = {
+    0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x03,
+    0x20, 0x00, 0x00, 0x02, 0x58, 0x08, 0x02, 0x00, 0x00, 0x00, 0x15, 0x14, 0x15, 0x27, 0x00, 0x00, 0x08, 0xCF, 0x49,
+    0x44, 0x41, 0x54, 0x78, 0xDA, 0xED, 0xD6, 0x31, 0x11, 0x00, 0x30, 0x08, 0x00, 0xB1, 0x52, 0x21, 0xE8, 0x44, 0x22,
+    0xB2, 0x30, 0xC1, 0x31, 0x25, 0x12, 0x7E, 0xFA, 0xC8, 0xEA, 0x07, 0x00, 0xC0, 0x9E, 0x2F, 0x01, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58,
+    0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80,
+    0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x83, 0x25, 0x01, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80,
+    0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00,
+    0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80,
+    0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x25, 0x01, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0xDC, 0x19, 0x79, 0xA5, 0x06, 0x0E, 0x33, 0xD4, 0xAF,
+    0xF2, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
+};
+
+// Draws that take a millisecond every fourth row, so decoding PNG_SOLID always outlasts the time limit of one call
+class SlowDraws : public runtime_image::PngDecoder, public runtime_image::RuntimeImage {
+ public:
+  static void install(runtime_image::RuntimeImage &image) {
+    auto *decoder = static_cast<runtime_image::PngDecoder *>((image.*&SlowDraws::decoder_).get());
+    pngle_set_draw_callback(decoder->*&SlowDraws::pngle_, draw);
+  }
+
+ private:
+  static void draw(pngle_t *pngle, uint32_t x, uint32_t y, uint32_t w, uint32_t h, const uint8_t rgba[4]) {
+    if (x == 0 && y % 4 == 0) {
+      const uint32_t until = millis() + 2;
+      while (millis() < until) {
+      }
+    }
+    static_cast<runtime_image::PngDecoder *>(pngle_get_user_data(pngle))
+        ->draw(x, y, w, h, Color(rgba[0], rgba[1], rgba[2], rgba[3]));
+  }
+};
+
 // 8x8 progressive JPEG, 521 bytes
 static const uint8_t JPEG_PROGRESSIVE[] = {
     0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
@@ -458,6 +607,30 @@ TEST_F(OnlineImageDownloadEnd, JpegBufferAllocationFailureReportsError) {
   EXPECT_EQ(this->finished_, 0);
 }
 
+// The whole PNG arrives in one read, but the decoder stops after a short time per call: the rest is decoded on
+// later passes, not reported as data the decoder could not use
+TEST_F(OnlineImageDownloadEnd, PngDecodedOverSeveralPassesAfterTheDownloadEnds) {
+  for (bool chunked : {false, true}) {
+    this->finished_ = 0;
+    this->errors_ = 0;
+    auto image = this->make_image_(runtime_image::PNG, 4096);
+    auto container = std::make_shared<FakeContainer>(std::vector<uint8_t>(PNG_SOLID, PNG_SOLID + sizeof(PNG_SOLID)),
+                                                     sizeof(PNG_SOLID), chunked);
+    this->start_(*image, container);
+    SlowDraws::install(*image);
+
+    int passes = 0;
+    for (; passes < 1000 && this->finished_ + this->errors_ == 0; passes++)
+      image->loop();
+
+    EXPECT_EQ(this->finished_, 1) << (chunked ? "chunked" : "with Content-Length");
+    EXPECT_EQ(this->errors_, 0);
+    EXPECT_GT(passes, 2);
+    EXPECT_EQ(image->get_width(), 800);
+    EXPECT_EQ(image->get_pixel(400, 300).b, 200);
+  }
+}
+
 // The JPEG decoded with all of it in memory at once, to compare the downloaded images with
 static std::vector<uint8_t> reference_jpeg_pixels() {
   runtime_image::RuntimeImage ref(runtime_image::JPEG, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);

tests/components/runtime_image/test_decode_time_limit.cpp

@@ -0,0 +1,151 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "esphome/components/runtime_image/qoi_decoder.h"
+#include "esphome/components/runtime_image/runtime_image.h"
+
+namespace esphome::runtime_image::testing {
+
+// Big enough that decoding it takes well over DECODE_TIME_LIMIT_MS, little enough to build quickly
+static constexpr uint32_t WIDTH = 4096;
+static constexpr uint32_t HEIGHT = 2048;
+
+static void put_le32(std::vector<uint8_t> &data, size_t offset, uint32_t value) {
+  for (size_t i = 0; i < 4; i++)
+    data[offset + i] = (value >> (8 * i)) & 0xFF;
+}
+
+static void put_be32(std::vector<uint8_t> &data, size_t offset, uint32_t value) {
+  for (size_t i = 0; i < 4; i++)
+    data[offset + i] = (value >> (24 - 8 * i)) & 0xFF;
+}
+
+// A 1-bit BMP with the left half of every row set: eight pixels for each byte read
+static std::vector<uint8_t> make_mono_bmp() {
+  constexpr size_t data_offset = 14 + 40 + 2 * 4;
+  constexpr size_t row_bytes = WIDTH / 8;
+  std::vector<uint8_t> bmp(data_offset + row_bytes * HEIGHT, 0);
+  bmp[0] = 'B';
+  bmp[1] = 'M';
+  put_le32(bmp, 2, bmp.size());
+  put_le32(bmp, 10, data_offset);
+  put_le32(bmp, 14, 40);  // DIB header size
+  put_le32(bmp, 18, WIDTH);
+  put_le32(bmp, 22, HEIGHT);
+  bmp[26] = 1;  // color planes
+  bmp[28] = 1;  // bits per pixel
+  for (size_t row = 0; row < HEIGHT; row++) {
+    for (size_t i = 0; i < row_bytes / 2; i++)
+      bmp[data_offset + row * row_bytes + i] = 0xFF;
+  }
+  return bmp;
+}
+
+// A QOI image of one color: an RGB chunk, then runs of 62 pixels, each run a single byte
+static std::vector<uint8_t> make_solid_qoi() {
+  std::vector<uint8_t> qoi(14, 0);
+  qoi[0] = 'q';
+  qoi[1] = 'o';
+  qoi[2] = 'i';
+  qoi[3] = 'f';
+  put_be32(qoi, 4, WIDTH);
+  put_be32(qoi, 8, HEIGHT);
+  qoi[12] = 3;  // channels
+  qoi.insert(qoi.end(), {0xFE, 30, 120, 200});
+  for (size_t left = WIDTH * HEIGHT - 1; left > 0;) {
+    const size_t run = std::min<size_t>(left, 62);
+    qoi.push_back(0xC0 | (run - 1));
+    left -= run;
+  }
+  qoi.insert(qoi.end(), {0, 0, 0, 0, 0, 0, 0, 1});
+  return qoi;
+}
+
+// Feed the whole image as often as it takes, and return how many calls that was
+static int decode_in_calls(RuntimeImage &img, std::vector<uint8_t> &data) {
+  EXPECT_TRUE(img.begin_decode(data.size()));
+  size_t offset = 0;
+  int calls = 0;
+  while (offset < data.size() && calls < 10000) {
+    const int consumed = img.feed_data(data.data() + offset, data.size() - offset);
+    EXPECT_GT(consumed, 0);
+    if (consumed <= 0)
+      break;
+    offset += consumed;
+    calls++;
+  }
+  EXPECT_EQ(offset, data.size());
+  EXPECT_TRUE(img.end_decode());
+  return calls;
+}
+
+TEST(DecodeTimeLimit, BmpIsDecodedOverSeveralCalls) {
+  RuntimeImage img(BMP, image::IMAGE_TYPE_GRAYSCALE, image::TRANSPARENCY_OPAQUE);
+  auto data = make_mono_bmp();
+  EXPECT_GT(decode_in_calls(img, data), 1) << "the whole image was decoded in one call";
+  ASSERT_EQ(img.get_width(), static_cast<int>(WIDTH));
+  ASSERT_EQ(img.get_height(), static_cast<int>(HEIGHT));
+  for (auto [col, row] : {std::pair{0, 0}, std::pair{1000, 1000}, std::pair{4095, 2047}}) {
+    const uint8_t expected = col < static_cast<int>(WIDTH / 2) ? 255 : 0;
+    EXPECT_EQ(img.get_pixel(col, row).r, expected) << col << "," << row;
+  }
+}
+
+// Bytes after the pixel data are used up, not drawn; here they would be colour indexes past the end of the table
+TEST(DecodeTimeLimit, BmpIgnoresBytesAfterThePixels) {
+  RuntimeImage img(BMP, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+  constexpr size_t data_offset = 14 + 40 + 2 * 4;
+  std::vector<uint8_t> data(data_offset, 0);
+  data[0] = 'B';
+  data[1] = 'M';
+  put_le32(data, 10, data_offset);
+  put_le32(data, 14, 40);  // DIB header size
+  put_le32(data, 18, 2);   // width
+  put_le32(data, 22, 1);   // height
+  data[26] = 1;            // color planes
+  data[28] = 8;            // bits per pixel
+  data[46] = 2;            // colors in the table
+  put_le32(data, 54, 0xFF0000);
+  put_le32(data, 58, 0x0000FF);
+  data.insert(data.end(), {0, 1, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF});
+  put_le32(data, 2, data.size());
+
+  ASSERT_TRUE(img.begin_decode(data.size()));
+  EXPECT_EQ(img.feed_data(data.data(), data.size()), static_cast<int>(data.size()));
+  ASSERT_TRUE(img.end_decode());
+  EXPECT_EQ(img.get_pixel(0, 0).r, 255);
+  EXPECT_EQ(img.get_pixel(1, 0).b, 255);
+}
+
+TEST(DecodeTimeLimit, QoiIsDecodedOverSeveralCalls) {
+  RuntimeImage img(QOI, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+  auto data = make_solid_qoi();
+  EXPECT_GT(decode_in_calls(img, data), 1) << "the whole image was decoded in one call";
+  for (auto [col, row] : {std::pair{0, 0}, std::pair{2000, 1000}, std::pair{4095, 2047}}) {
+    const Color pixel = img.get_pixel(col, row);
+    EXPECT_EQ(pixel.r, 30);
+    EXPECT_EQ(pixel.g, 120);
+    EXPECT_EQ(pixel.b, 200);
+  }
+}
+
+// A chunk split across two calls: the bytes used before the split count towards the decoded total
+TEST(DecodeTimeLimit, QoiCountsTheBytesBeforeASplitChunk) {
+  RuntimeImage img(QOI, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+  std::vector<uint8_t> data = {'q', 'o', 'i', 'f', 0, 0, 0, 2, 0, 0, 0, 1, 3, 0};
+  data.insert(data.end(), {0xFE, 10, 20, 30, 0xFE, 40, 50, 60, 0, 0, 0, 0, 0, 0, 0, 1});
+  QoiDecoder decoder(&img);
+  ASSERT_EQ(decoder.prepare(data.size()), 0);
+
+  // The header and the first chunk, and half of the second
+  EXPECT_EQ(decoder.decode(data.data(), 20), 18);
+  EXPECT_EQ(decoder.get_decoded_bytes(), 18u);
+  EXPECT_EQ(decoder.decode(data.data() + 18, data.size() - 18), static_cast<int>(data.size() - 18));
+  EXPECT_EQ(decoder.get_decoded_bytes(), data.size());
+  EXPECT_TRUE(decoder.is_finished());
+}
+
+}  // namespace esphome::runtime_image::testing

tests/components/runtime_image/test_decoder_reuse.cpp

@@ -5,9 +5,11 @@
 #include <array>
 #include <cstdlib>
 #include <cstring>
+#include <tuple>
 #include <utility>
 #include <vector>
 
+#include "esphome/components/display/display_color_utils.h"
 #include "esphome/components/runtime_image/image_decoder.h"
 #include "esphome/components/runtime_image/jpeg_decoder.h"
 #include "esphome/components/runtime_image/runtime_image.h"
@@ -470,7 +472,7 @@ TEST(RuntimeImageDecoder, JpegDecodesToScaledRgb) {
 }
 
 // Target pixel index each source pixel paints when `source` pixels map onto `target`, the way
-// prepare_rgb565_scaling_ rounds: source n covers targets ceil(n * target / source) up to the next start
+// prepare_draw_ rounds: source n covers targets ceil(n * target / source) up to the next start
 static uint16_t scaled_boundary(int n, int source, int target) { return (n * target + source - 1) / source; }
 
 // Every target pixel of a PNG drawn at a size that is not a whole multiple: enlarged with spans 1 or 2 pixels wide, and
@@ -594,4 +596,152 @@ TEST(RuntimeImageDecoder, SessionFlagsTrackLifecycle) {
   EXPECT_FALSE(img.is_decode_finished()) << "no session means nothing is 'finished'";
 }
 
+// 5x3 QOI whose runs carry on from one row into the next
+static const uint8_t QOI_RUNS[] = {
+    'q',  'o', 'i', 'f', 0, 0, 0, 5, 0, 0, 0, 3, 3, 0,  // header
+    0xFE, 10,  20,  30,                                 // 1 pixel
+    0xC5,                                               // a run of 6
+    0xFE, 200, 100, 50,                                 // 1 pixel
+    0xC6,                                               // a run of 7
+    0,    0,   0,   0,   0, 0, 0, 1,                    // end marker
+};
+
+/// Decode a whole image into img
+static void decode_into(RuntimeImage &img, ImageFormat format, const uint8_t *data, size_t len) {
+  std::vector<uint8_t> buffer(data, data + len);
+  ASSERT_TRUE(img.begin_decode(len, format));
+  size_t offset = 0;
+  while (offset < len) {
+    const int consumed = img.feed_data(buffer.data() + offset, len - offset);
+    ASSERT_GT(consumed, 0);
+    offset += consumed;
+  }
+  ASSERT_TRUE(img.end_decode());
+}
+
+// An opaque RGB565 image is written straight into the buffer. It must hold the same pixels, in the same places, as an
+// RGB image filled through draw_pixel(), at the image's own size and scaled.
+TEST(RuntimeImageDecoder, DirectRgb565MatchesTheGenericPath) {
+  const std::tuple<ImageFormat, const uint8_t *, size_t> images[] = {
+      {BMP, BMP_24BPP, sizeof(BMP_24BPP)},
+      {BMP, BMP_8BPP, sizeof(BMP_8BPP)},
+      {PNG, PNG_RGB, sizeof(PNG_RGB)},
+      {QOI, QOI_RUNS, sizeof(QOI_RUNS)},
+  };
+  for (auto [format, data, len] : images) {
+    for (auto [width, height] : {std::pair{0, 0}, std::pair{7, 5}, std::pair{2, 2}, std::pair{9, 2}}) {
+      RuntimeImage reference(format, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE, nullptr, false, width, height);
+      decode_into(reference, format, data, len);
+      for (bool big_endian : {false, true}) {
+        RuntimeImage img(format, image::IMAGE_TYPE_RGB565, image::TRANSPARENCY_OPAQUE, nullptr, big_endian, width,
+                         height);
+        decode_into(img, format, data, len);
+        ASSERT_EQ(img.get_width(), reference.get_width());
+        ASSERT_EQ(img.get_height(), reference.get_height());
+        const uint8_t *pixels = img.get_data_start();
+        for (int i = 0; i < img.get_width() * img.get_height(); i++) {
+          const Color color = reference.get_pixel(i % img.get_width(), i / img.get_width());
+          const uint16_t expected = display::ColorUtil::color_to_565(color);
+          const uint16_t actual =
+              big_endian ? (pixels[i * 2] << 8 | pixels[i * 2 + 1]) : (pixels[i * 2] | pixels[i * 2 + 1] << 8);
+          EXPECT_EQ(actual, expected) << "image of " << len << " bytes into " << width << "x" << height
+                                      << (big_endian ? " big-endian" : " little-endian") << ", pixel " << i;
+        }
+      }
+    }
+  }
+}
+
+// The runs fill the rows they carry on into
+TEST(RuntimeImageDecoder, QoiRunsCrossRows) {
+  TestableRuntimeImage img(QOI);
+  ASSERT_TRUE(decode_all(img, QOI_RUNS, sizeof(QOI_RUNS)));
+  for (int i = 0; i < 15; i++) {
+    const Color pixel = img.get_pixel(i % 5, i / 5);
+    const bool second = i >= 7;
+    EXPECT_EQ(pixel.r, second ? 200 : 10) << "pixel " << i;
+    EXPECT_EQ(pixel.g, second ? 100 : 20) << "pixel " << i;
+    EXPECT_EQ(pixel.b, second ? 50 : 30) << "pixel " << i;
+  }
+}
+
+// 8x2 1bpp BMP: the top row has its right half set, the bottom row its left half (rows padded to 4 bytes)
+static const uint8_t BMP_1BPP[] = {
+    0x42, 0x4D, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x13, 0x0B, 0x00, 0x00, 0x13, 0x0B, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
+};
+
+// BMP has no alpha, so no pixel may come out transparent, whatever transparency the image has
+TEST(RuntimeImageDecoder, BmpPixelsAreOpaque) {
+  const std::pair<const uint8_t *, size_t> images[] = {
+      {BMP_24BPP, sizeof(BMP_24BPP)},
+      {BMP_8BPP, sizeof(BMP_8BPP)},
+      {BMP_1BPP, sizeof(BMP_1BPP)},
+  };
+  for (auto transparency : {image::TRANSPARENCY_ALPHA_CHANNEL, image::TRANSPARENCY_CHROMA_KEY}) {
+    for (auto type : {image::IMAGE_TYPE_RGB, image::IMAGE_TYPE_RGB565}) {
+      for (auto [data, len] : images) {
+        RuntimeImage img(BMP, type, transparency, nullptr, false, 0, 0);
+        decode_into(img, BMP, data, len);
+        for (int y = 0; y < img.get_height(); y++) {
+          for (int x = 0; x < img.get_width(); x++) {
+            EXPECT_EQ(img.get_pixel(x, y).w, 0xFF) << "image of " << len << " bytes, type " << type << ", transparency "
+                                                   << transparency << ", pixel (" << x << "," << y << ")";
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(RuntimeImageDecoder, Bmp1BppPixels) {
+  TestableRuntimeImage img(BMP, image::TRANSPARENCY_ALPHA_CHANNEL);
+  ASSERT_TRUE(decode_all(img, BMP_1BPP, sizeof(BMP_1BPP)));
+  ASSERT_EQ(img.get_width(), 8);
+  ASSERT_EQ(img.get_height(), 2);
+  for (int x = 0; x < 8; x++) {
+    EXPECT_EQ(img.get_pixel(x, 0).r, x >= 4 ? 0xFF : 0x00) << "pixel (" << x << ",0)";
+    EXPECT_EQ(img.get_pixel(x, 1).r, x < 4 ? 0xFF : 0x00) << "pixel (" << x << ",1)";
+  }
+}
+
+/// Reads a decoder's protected boundary tables
+struct BoundaryTables : ImageDecoder {
+  static size_t x_capacity(const ImageDecoder &decoder) {
+    return (decoder.*(&BoundaryTables::x_boundaries_)).capacity();
+  }
+  static size_t y_capacity(const ImageDecoder &decoder) {
+    return (decoder.*(&BoundaryTables::y_boundaries_)).capacity();
+  }
+  static bool size_valid(const ImageDecoder &decoder) { return decoder.*(&BoundaryTables::size_valid_); }
+  static void prepare_draw(ImageDecoder &decoder, int width, int height) {
+    (decoder.*(&BoundaryTables::prepare_draw_))(width, height);
+  }
+};
+
+// A JPEG decoded at reduced size builds its tables once, for the decoded size, not first for the full size
+TEST(RuntimeImageDecoder, JpegTablesAreBuiltForTheDecodedSize) {
+  TestableRuntimeImage img(JPEG, image::IMAGE_TYPE_RGB565, false, 1, 1);
+  ASSERT_TRUE(decode_all(img, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
+  ASSERT_EQ(static_cast<JpegDecoder *>(img.decoder())->get_scale(), 8);
+  EXPECT_EQ(BoundaryTables::x_capacity(*img.decoder()), 2u);
+  EXPECT_EQ(BoundaryTables::y_capacity(*img.decoder()), 2u);
+}
+
+// Without memory for the tables an RGB565 image is drawn pixel by pixel, rather than failing the decode
+TEST(RuntimeImageDecoder, DirectDrawFallsBackWhenTablesCannotBeAllocated) {
+  TestableRuntimeImage img(BMP, image::IMAGE_TYPE_RGB565, false, 0, 0);
+  ASSERT_TRUE(img.begin_decode(sizeof(BMP_24BPP)));
+  BoundaryTables::prepare_draw(*img.decoder(), 3, 2);
+  ASSERT_TRUE(img.decoder()->uses_direct_rgb565());
+  // The x table already fits; a y table of SIZE_MAX entries can never be allocated
+  BoundaryTables::prepare_draw(*img.decoder(), 3, -2);
+  EXPECT_FALSE(img.decoder()->uses_direct_rgb565());
+  EXPECT_TRUE(BoundaryTables::size_valid(*img.decoder())) << "draw() would paint nothing";
+  EXPECT_EQ(BoundaryTables::x_capacity(*img.decoder()), 0u) << "the unused x table is kept";
+  EXPECT_EQ(BoundaryTables::y_capacity(*img.decoder()), 0u);
+}
+
 }  // namespace esphome::runtime_image::testing

tests/components/runtime_image/test_grayscale_pixel.cpp

@@ -0,0 +1,35 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <cstdlib>
+
+#include "esphome/components/runtime_image/runtime_image.h"
+
+namespace esphome::runtime_image::testing {
+
+class GrayscaleImage : public RuntimeImage {
+ public:
+  GrayscaleImage() : RuntimeImage(BMP, image::IMAGE_TYPE_GRAYSCALE, image::TRANSPARENCY_OPAQUE) {}
+  uint8_t pixel(int x) const { return this->buffer_[x]; }
+};
+
+// The integer weights stay within one step of the floating point formula they replace, and keep white at 255
+TEST(GrayscalePixel, MatchesTheFloatingPointWeights) {
+  GrayscaleImage img;
+  ASSERT_GT(img.resize(256, 1), 0);
+  for (int r = 0; r < 256; r += 5) {
+    for (int g = 0; g < 256; g += 5) {
+      for (int b = 0; b < 256; b += 5) {
+        img.draw_pixel(0, 0, Color(r, g, b));
+        const int expected = static_cast<int>(0.2125 * r + 0.7154 * g + 0.0721 * b);
+        ASSERT_LE(std::abs(img.pixel(0) - expected), 1) << "r=" << r << " g=" << g << " b=" << b;
+      }
+    }
+  }
+  img.draw_pixel(1, 0, Color(255, 255, 255));
+  EXPECT_EQ(img.pixel(1), 255);
+  img.draw_pixel(2, 0, Color(0, 0, 0));
+  EXPECT_EQ(img.pixel(2), 0);
+}
+
+}  // namespace esphome::runtime_image::testing

tests/components/runtime_image/test_png_time_limit.cpp

@@ -0,0 +1,204 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "esphome/components/runtime_image/png_decoder.h"
+#include "esphome/components/runtime_image/runtime_image.h"
+#include "esphome/core/hal.h"
+#include "pngle.h"
+
+namespace esphome::runtime_image::testing {
+
+// 800x600 RGB PNG of a single color (30, 120, 200), 2312 bytes: little data, but many pixels to draw.
+// The same bytes are in tests/components/online_image/test_download_end.cpp.
+static const uint8_t PNG_SOLID[] = {
+    0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x03,
+    0x20, 0x00, 0x00, 0x02, 0x58, 0x08, 0x02, 0x00, 0x00, 0x00, 0x15, 0x14, 0x15, 0x27, 0x00, 0x00, 0x08, 0xCF, 0x49,
+    0x44, 0x41, 0x54, 0x78, 0xDA, 0xED, 0xD6, 0x31, 0x11, 0x00, 0x30, 0x08, 0x00, 0xB1, 0x52, 0x21, 0xE8, 0x44, 0x22,
+    0xB2, 0x30, 0xC1, 0x31, 0x25, 0x12, 0x7E, 0xFA, 0xC8, 0xEA, 0x07, 0x00, 0xC0, 0x9E, 0x2F, 0x01, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58,
+    0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80,
+    0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x83, 0x25, 0x01, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80,
+    0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00,
+    0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16,
+    0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00,
+    0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80,
+    0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30,
+    0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1,
+    0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58,
+    0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02,
+    0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00,
+    0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00,
+    0x06, 0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0,
+    0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x25, 0x01, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06,
+    0x0B, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60,
+    0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B,
+    0x00, 0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01,
+    0x00, 0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00,
+    0x00, 0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00,
+    0x18, 0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00,
+    0x83, 0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18,
+    0x2C, 0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83,
+    0x05, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0,
+    0x00, 0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05,
+    0x00, 0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00,
+    0x00, 0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0x30, 0x58, 0x00, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00,
+    0x60, 0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00,
+    0x0C, 0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x18, 0x2C, 0x00, 0x00, 0x83, 0x05, 0x00, 0x60,
+    0xB0, 0x00, 0x00, 0x30, 0x58, 0x00, 0x00, 0x06, 0x0B, 0x00, 0xC0, 0x60, 0x01, 0x00, 0x60, 0xB0, 0x00, 0x00, 0x0C,
+    0x16, 0x00, 0x80, 0xC1, 0x02, 0x00, 0xC0, 0x60, 0x01, 0x00, 0xDC, 0x19, 0x79, 0xA5, 0x06, 0x0E, 0x33, 0xD4, 0xAF,
+    0xF2, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
+};
+
+// A 1x1 RGB PNG whose IEND chunk header crosses the end of the first 64 byte piece
+static const uint8_t PNG_1X1[] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48,
+                                  0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, 0x00, 0x00,
+                                  0x00, 0x90, 0x77, 0x53, 0xDE, 0x00, 0x00, 0x00, 0x0C, 0x49, 0x44, 0x41, 0x54, 0x78,
+                                  0x9C, 0x63, 0xF8, 0xCF, 0xC0, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0xC9, 0xFE, 0x92,
+                                  0xEF, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82};
+
+// Draws that take a millisecond every fourth row, so decoding PNG_SOLID always outlasts the time limit of one call
+class SlowDraws : public PngDecoder, public RuntimeImage {
+ public:
+  static void install(RuntimeImage &image) {
+    auto *decoder = static_cast<PngDecoder *>((image.*&SlowDraws::decoder_).get());
+    pngle_set_draw_callback(decoder->*&SlowDraws::pngle_, draw);
+  }
+
+ private:
+  static void draw(pngle_t *pngle, uint32_t x, uint32_t y, uint32_t w, uint32_t h, const uint8_t rgba[4]) {
+    if (x == 0 && y % 4 == 0) {
+      const uint32_t until = millis() + 2;
+      while (millis() < until) {
+      }
+    }
+    static_cast<PngDecoder *>(pngle_get_user_data(pngle))->draw(x, y, w, h, Color(rgba[0], rgba[1], rgba[2], rgba[3]));
+  }
+};
+
+// One feed_data() call stops after a short time, so a large image is decoded over several calls
+TEST(PngTimeLimit, LargeImageIsDecodedOverSeveralCalls) {
+  RuntimeImage img(PNG, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+  std::vector<uint8_t> data(PNG_SOLID, PNG_SOLID + sizeof(PNG_SOLID));
+  ASSERT_TRUE(img.begin_decode(data.size()));
+  SlowDraws::install(img);
+
+  size_t offset = 0;
+  int calls = 0;
+  while (offset < data.size() && calls < 1000) {
+    const int consumed = img.feed_data(data.data() + offset, data.size() - offset);
+    ASSERT_GT(consumed, 0);
+    offset += consumed;
+    calls++;
+  }
+  EXPECT_GT(calls, 1) << "the whole image was decoded in one call";
+  ASSERT_EQ(offset, data.size());
+  ASSERT_TRUE(img.end_decode());
+
+  ASSERT_EQ(img.get_width(), 800);
+  ASSERT_EQ(img.get_height(), 600);
+  for (auto [col, row] : {std::pair{0, 0}, std::pair{400, 300}, std::pair{799, 599}}) {
+    const Color pixel = img.get_pixel(col, row);
+    EXPECT_EQ(pixel.r, 30);
+    EXPECT_EQ(pixel.g, 120);
+    EXPECT_EQ(pixel.b, 200);
+  }
+}
+
+// A chunk header that crosses the end of a piece does not end the call
+TEST(PngTimeLimit, ChunkAcrossAPieceDoesNotEndTheCall) {
+  RuntimeImage img(PNG, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+  std::vector<uint8_t> data(PNG_1X1, PNG_1X1 + sizeof(PNG_1X1));
+  ASSERT_TRUE(img.begin_decode(data.size()));
+  EXPECT_EQ(img.feed_data(data.data(), data.size()), static_cast<int>(data.size()));
+}
+
+}  // namespace esphome::runtime_image::testing