Merge branch 'runtime-image-integer-draw' into runtime-image-gray-integer

Merge branch 'runtime-image-jpeg-scale' into runtime-image-integer-draw
Merge branch 'online-image-progress' into runtime-image-jpeg-scale
2026-10-22 13:56:10 +00:00 · 2026-10-22 22:03:59 +11:00 · 2026-10-22 22:03:58 +11:00 · 2026-10-22 22:03:58 +11:00 · 2026-10-22 22:03:58 +11:00 · 2026-10-22 22:03:57 +11:00
47 changed files with 1647 additions and 764 deletions
@@ -1,7 +1,5 @@
-from collections.abc import Callable
 from ipaddress import IPv4Address, IPv6Address
 import logging
-import math
 import re
 from typing import Any

@@ -29,7 +27,6 @@ from esphome.const import (
    CONF_CAPTURE_RESPONSE,
    CONF_DATA,
    CONF_DATA_TEMPLATE,
-    CONF_DEFAULT,
    CONF_DELAY,
    CONF_ENCRYPTION,
    CONF_EVENT,
@@ -139,7 +136,6 @@ SERVICE_ARG_FALLBACK_TYPES: dict[str, MockObj] = {
 CONF_BATCH_DELAY = "batch_delay"
 CONF_CUSTOM_SERVICES = "custom_services"
 CONF_EXAMPLE = "example"
-CONF_REQUIRED = "required"
 CONF_HOMEASSISTANT_SERVICES = "homeassistant_services"
 CONF_HOMEASSISTANT_STATES = "homeassistant_states"
 CONF_LISTEN_BACKLOG = "listen_backlog"
@@ -251,66 +247,12 @@ def _validate_supports_response(value: Any) -> str:
    return cv.enum(SUPPORTS_RESPONSE_OPTIONS, lower=True)(value)


-def _not_boolean(value: Any) -> Any:
-    # bool is an int subclass, and "true" cannot be parsed as a number by the client
-    if isinstance(value, bool):
-        raise cv.Invalid("Expected a number, got a boolean")
-    return value
-
-
-def _finite(value: float) -> float:
-    if not math.isfinite(value):
-        raise cv.Invalid("Expected a finite number")
-    return value
-
-
-def _no_nul(value: str) -> str:
-    # The default is a C string in flash, so a NUL would cut it short
-    if "\0" in value:
-        raise cv.Invalid("A default cannot contain a NUL character")
-    return value
-
-
-# The wire carries the default as text; the client parses it into ExecuteServiceArgument's
-# types, so the values are kept within what int32 and float hold
-FLOAT32_MAX = 3.4028235e38
-_DEFAULT_VALUE_VALIDATORS: dict[str, Callable[[Any], Any]] = {
-    "bool": cv.boolean,
-    "int": cv.All(_not_boolean, cv.int_range(min=-(2**31), max=2**31 - 1)),
-    "float": cv.All(
-        _not_boolean,
-        cv.float_,
-        _finite,
-        cv.float_range(min=-FLOAT32_MAX, max=FLOAT32_MAX),
-    ),
-    "string": cv.All(cv.string_strict, _no_nul),
-}
-assert _DEFAULT_VALUE_VALIDATORS.keys() == _SERVICE_ARG_SCALAR_TYPES.keys()
-
-
-def _validate_variable_optionality(value: ConfigType) -> ConfigType:
-    """Cross-validate required/default against the variable type."""
-    var_type = value[CONF_TYPE]
-    if _is_optional_var(value) and var_type not in _DEFAULT_VALUE_VALIDATORS:
-        raise cv.Invalid("Array variables cannot be optional")
-    if CONF_DEFAULT in value:
-        if value.get(CONF_REQUIRED) is True:
-            raise cv.Invalid("A variable with a default cannot set required: true")
-        value[CONF_DEFAULT] = _DEFAULT_VALUE_VALIDATORS[var_type](value[CONF_DEFAULT])
-    return value
-
-
-VARIABLE_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Required(CONF_TYPE): cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
-            cv.Optional(CONF_DESCRIPTION): cv.string_strict,
-            cv.Optional(CONF_EXAMPLE): cv.string_strict,
-            cv.Optional(CONF_REQUIRED): cv.boolean,
-            cv.Optional(CONF_DEFAULT): cv.valid,
-        }
-    ),
-    _validate_variable_optionality,
+VARIABLE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_TYPE): cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
+        cv.Optional(CONF_DESCRIPTION): cv.string_strict,
+        cv.Optional(CONF_EXAMPLE): cv.string_strict,
+    }
 )

 # Accepts the plain `name: type` shorthand or the full mapping form
@@ -522,28 +464,7 @@ def _has_action_metadata(actions: list[ConfigType]) -> bool:
    )


-def _is_optional_var(var_: ConfigType) -> bool:
-    return CONF_DEFAULT in var_ or var_.get(CONF_REQUIRED) is False
-
-
-def _has_optional_args(actions: list[ConfigType]) -> bool:
-    return any(
-        _is_optional_var(var_)
-        for conf in actions
-        for var_ in conf[CONF_VARIABLES].values()
-    )
-
-
-def _default_to_wire(value: Any) -> str:
-    """Serialize a validated default for the wire; clients coerce by arg type."""
-    if isinstance(value, bool):
-        return "true" if value else "false"
-    return str(value)
-
-
-def _action_strings(
-    conf: ConfigType, has_metadata: bool, has_optional: bool
-) -> list[str | None]:
+def _action_strings(conf: ConfigType, has_metadata: bool) -> list[str | None]:
    """Strings of one action in the table order UserServiceStatic (user_services.h) expects."""
    # An empty description or example is treated as unset
    strings: list[str | None] = [conf[CONF_ACTION]]
@@ -556,15 +477,6 @@ def _action_strings(
                var_.get(CONF_DESCRIPTION) or None,
                var_.get(CONF_EXAMPLE) or None,
            ]
-        if has_optional:
-            # The default slot doubles as the optional flag: nullptr for a required variable,
-            # "" for an optional one without a default (an empty string default is the same)
-            if not _is_optional_var(var_):
-                strings.append(None)
-            elif (default := var_.get(CONF_DEFAULT)) is None:
-                strings.append("")
-            else:
-                strings.append(_default_to_wire(default))
    return strings


@@ -573,7 +485,9 @@ def _validate_wizard(config: ConfigType) -> ConfigType:
    return config


-FINAL_VALIDATE_SCHEMA = _validate_wizard
+FINAL_VALIDATE_SCHEMA = cv.All(
+    _validate_wizard,
+)


 def _add_action_strings(index: int, strings: list[str | None]) -> MockObj:
@@ -632,9 +546,6 @@ async def to_code(config: ConfigType) -> None:
        has_metadata = _has_action_metadata(actions)
        if has_metadata:
            cg.add_define("USE_API_USER_DEFINED_ACTION_METADATA")
-        has_optional = _has_optional_args(actions)
-        if has_optional:
-            cg.add_define("USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS")
        # Collect all triggers first, then register all at once with initializer_list
        triggers: list[cg.MockObj] = []
        for index, conf in enumerate(actions):
@@ -678,7 +589,7 @@ async def to_code(config: ConfigType) -> None:
                    native = SERVICE_ARG_NATIVE_TYPES[var_type]
                service_template_args.append(native)
                func_args.append((native, name))
-            strings = _action_strings(conf, has_metadata, has_optional)
+            strings = _action_strings(conf, has_metadata)
            table = _add_action_strings(index, strings)
            # Template args: supports_response mode, then user service arg types
            templ = cg.TemplateArguments(supports_response, *service_template_args)
@@ -1174,10 +1174,6 @@ message ListEntitiesServicesArgument {
  ServiceArgType type = 2;
  string description = 3 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
  string example = 4 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
-  // Advisory: ExecuteServiceRequest still requires every argument
-  bool optional = 5 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS"];
-  // Always text: bool "true"/"false", numbers parseable as int/float; empty means no default
-  string default_value = 6 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS", (progmem) = true];
 }
 message ListEntitiesServicesResponse {
  option (id) = 41;
@@ -1369,12 +1369,6 @@ uint8_t *ListEntitiesServicesArgument::encode_msg(const void *self,
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.example);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.optional);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.default_value);
 #endif
  return pos;
 }
@@ -1388,12 +1382,6 @@ uint32_t ListEntitiesServicesArgument::calc_size_msg(const void *self) {
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
  size += ProtoSize::calc_length(1, msg.example.size());
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  size += ProtoSize::calc_bool(1, msg.optional);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  size += ProtoSize::calc_length(1, msg.default_value.size());
 #endif
  return size;
 }
@@ -1593,12 +1593,6 @@ class ListEntitiesServicesArgument final : public ProtoMessage {
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
  ProgmemStringRef example{};
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  bool optional{false};
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  ProgmemStringRef default_value{};
 #endif
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1643,12 +1643,6 @@ const char *ListEntitiesServicesArgument::dump_to(DumpBuffer &out) const {
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
  dump_progmem_string_field(out, ESPHOME_PSTR("example"), this->example);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  dump_field(out, ESPHOME_PSTR("optional"), this->optional);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  dump_progmem_string_field(out, ESPHOME_PSTR("default_value"), this->default_value);
 #endif
  return out.c_str();
 }
@@ -31,13 +31,6 @@ ListEntitiesServicesResponse UserServiceStatic::encode_list_service_response_(
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
    arg.description = this->str_(base + 1);
    arg.example = this->str_(base + 2);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-    // The default slot doubles as the optional flag: nullptr is required, "" optional without a default
-    const char *d = progmem_read_ptr(&this->strings_[base + USER_ACTION_ARG_BASE_STRINGS]);
-    arg.optional = d != nullptr;
-    if (d != nullptr)
-      arg.default_value = ProgmemStringRef(d, ESPHOME_strlen_P(d));
 #endif
  }
  return msg;
@@ -40,20 +40,13 @@ template<typename T> enums::ServiceArgType to_service_arg_type();
 // All strings live in one PROGMEM pointer table emitted by codegen (see _action_strings in
 // __init__.py), so each service costs a single pointer of RAM. Layout: the action name, then
 // each argument name; with USE_API_USER_DEFINED_ACTION_METADATA the action description follows
-// the name and every argument is (name, description, example); with
-// USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS every argument ends with its default: nullptr for a
-// required argument, "" for an optional one without a default. Unset is nullptr.
+// the name and every argument is (name, description, example). Unset metadata is nullptr.
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
 static constexpr size_t USER_ACTION_HEADER_STRINGS = 2;
-static constexpr size_t USER_ACTION_ARG_BASE_STRINGS = 3;
+static constexpr size_t USER_ACTION_ARG_STRINGS = 3;
 #else
 static constexpr size_t USER_ACTION_HEADER_STRINGS = 1;
-static constexpr size_t USER_ACTION_ARG_BASE_STRINGS = 1;
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-static constexpr size_t USER_ACTION_ARG_STRINGS = USER_ACTION_ARG_BASE_STRINGS + 1;
-#else
-static constexpr size_t USER_ACTION_ARG_STRINGS = USER_ACTION_ARG_BASE_STRINGS;
+static constexpr size_t USER_ACTION_ARG_STRINGS = 1;
 #endif
 class UserServiceStatic : public UserServiceDescriptor {
 public:
@@ -35,7 +35,7 @@ async def to_code(config: ConfigType) -> None:
    await cg.add_variable(var.set_ota_parent, config[CONF_OTA_ID])
    await cg.add_variable(var.set_request_parent, config[CONF_HTTP_REQUEST_ID])

-    cg.add(var.set_source_url_static(config[CONF_SOURCE]))
+    cg.add(var.set_source_url(config[CONF_SOURCE]))

    ota.request_ota_state_listeners()

@@ -24,6 +24,12 @@ namespace esphome::http_request {

 ESPHOME_LOG_TAG(TAG, "http_request.update");

+// Wraps UpdateInfo + error for the task→main-loop handoff.
+struct TaskResult {
+  update::UpdateInfo info;
+  const LogString *error_str{nullptr};
+};
+
 static const size_t MAX_READ_SIZE = 256;
 static constexpr uint32_t INITIAL_CHECK_INTERVAL_ID = 0;
 static constexpr uint32_t INITIAL_CHECK_INTERVAL_MS = 10000;
@@ -62,37 +68,6 @@ void HttpRequestUpdate::on_ota_state(ota::OTAState state, float progress, uint8_
  }
 }

-void HttpRequestUpdate::set_source_url(const char *source_url, size_t len) {
-  // Copy before releasing, so a caller passing the current URL back in stays valid.
-  char *copy = new char[len + 1];
-  memcpy(copy, source_url, len);
-  copy[len] = '\0';
-  this->release_source_url_();
-  this->source_url_ = copy;
-  this->source_url_owned_ = true;
-}
-
-void HttpRequestUpdate::release_source_url_() {
-  if (this->source_url_owned_)
-    delete[] this->source_url_;
-  this->source_url_owned_ = false;
-}
-
-void HttpRequestUpdate::begin_check_(TaskResult *result) {
-  result->update = this;
-  result->source_url = this->source_url_;
-  result->owns_source_url = this->source_url_owned_;
-  this->source_url_owned_ = false;
-}
-
-void HttpRequestUpdate::end_check_(TaskResult *result) {
-  if (this->source_url_ == result->source_url) {
-    this->source_url_owned_ = result->owns_source_url;
-  } else if (result->owns_source_url) {
-    delete[] result->source_url;  // replaced while the check ran
-  }
-}
-
 void HttpRequestUpdate::update() {
  if (!network::is_connected()) {
    ESP_LOGD(TAG, "Network not connected, skipping update check");
@@ -100,37 +75,28 @@ void HttpRequestUpdate::update() {
  }
  this->cancel_interval(INITIAL_CHECK_INTERVAL_ID);
 #ifdef USE_ESP32
-  if (this->task_result_ != nullptr) {
+  if (this->update_task_handle_ != nullptr) {
    ESP_LOGW(TAG, "Update check already in progress");
    return;
  }
-#endif
-  // Allocated once per check; every path in the task returns via its single defer, which frees it.
-  auto *result = new TaskResult();
-  this->begin_check_(result);
-#ifdef USE_ESP32
-  this->task_result_ = result;
-  if (xTaskCreate(HttpRequestUpdate::update_task, "update_task", 8192, result, 1, nullptr) != pdPASS) {
-    this->task_result_ = nullptr;
-    this->end_check_(result);
-    delete result;
-  }
+  xTaskCreate(HttpRequestUpdate::update_task, "update_task", 8192, (void *) this, 1, &this->update_task_handle_);
 #else
-  this->update_task(result);
-  this->end_check_(result);
+  this->update_task(this);
 #endif
 }

 void HttpRequestUpdate::update_task(void *params) {
-  auto *result = static_cast<TaskResult *>(params);
-  HttpRequestUpdate *this_update = result->update;
-  auto *info = &result->info;
-  const char *source_url = result->source_url;
+  HttpRequestUpdate *this_update = (HttpRequestUpdate *) params;

-  auto container = this_update->request_parent_->get(source_url);
+  // Allocate once — every path below returns via the single defer at the end.
+  // On failure, error_str is set; on success it is nullptr.
+  auto *result = new TaskResult();
+  auto *info = &result->info;
+
+  auto container = this_update->request_parent_->get(this_update->source_url_);

  if (container == nullptr || container->status_code != HTTP_STATUS_OK) {
-    ESP_LOGE(TAG, "Failed to fetch manifest from %s", source_url);
+    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this_update->source_url_);
    if (container != nullptr)
      container->end();
    result->error_str = LOG_STR("Failed to fetch manifest");
@@ -210,14 +176,14 @@ void HttpRequestUpdate::update_task(void *params) {
    allocator.deallocate(data, content_length);

    if (!valid) {
-      ESP_LOGE(TAG, "Failed to parse JSON from %s", source_url);
+      ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_);
      result->error_str = LOG_STR("Failed to parse manifest JSON");
      goto defer;  // NOLINT(cppcoreguidelines-avoid-goto)
    }

    // Merge source_url_ and firmware_url
    if (!info->firmware_url.empty() && info->firmware_url.find("http") == std::string::npos) {
-      const char *source = source_url;
+      const char *source = this_update->source_url_;
      const size_t source_len = strlen(source);
      size_t prefix_len;
      if (info->firmware_url[0] == '/') {
@@ -249,8 +215,7 @@ defer:
  // Lambda captures only 2 pointers (8 bytes) — fits in std::function SBO on supported toolchains.
  this_update->defer([this_update, result]() {
 #ifdef USE_ESP32
-    this_update->task_result_ = nullptr;
-    this_update->end_check_(result);
+    this_update->update_task_handle_ = nullptr;
 #endif
    if (result->error_str != nullptr) {
      this_update->status_set_error(result->error_str);
@@ -13,21 +13,6 @@

 namespace esphome::http_request {

-namespace testing {
-class HttpRequestUpdateTest;
-}  // namespace testing
-
-class HttpRequestUpdate;
-
-// One manifest check: handed from update() to the task and back to the main loop.
-struct TaskResult {
-  HttpRequestUpdate *update{nullptr};
-  const char *source_url{nullptr};  // the URL this check reads, fixed before it starts
-  update::UpdateInfo info;
-  const LogString *error_str{nullptr};  // set on failure, nullptr on success
-  bool owns_source_url{false};          // the check holds the buffer until it ends, see begin_check_()
-};
-
 class HttpRequestUpdate final : public update::UpdateEntity, public PollingComponent, public ota::OTAStateListener {
 public:
  void setup() override;
@@ -36,18 +21,7 @@ class HttpRequestUpdate final : public update::UpdateEntity, public PollingCompo
  void perform(bool force) override;
  void check() override { this->update(); }

-  ~HttpRequestUpdate() override { this->release_source_url_(); }
-
-  /// Codegen only: the config literal lives in flash for the life of the program, so it is kept by pointer.
-  void set_source_url_static(const char *source_url) {
-    this->release_source_url_();
-    this->source_url_ = source_url;
-  }
-  /// Set the manifest URL at run time; the string is copied, so any storage may be passed.
-  void set_source_url(const char *source_url) { this->set_source_url(source_url, strlen(source_url)); }
-  void set_source_url(const std::string &source_url) { this->set_source_url(source_url.data(), source_url.size()); }
-  void set_source_url(const char *source_url, size_t len);
-  const char *get_source_url() const { return this->source_url_; }
+  void set_source_url(const char *source_url) { this->source_url_ = source_url; }

  void set_request_parent(HttpRequestComponent *request_parent) { this->request_parent_ = request_parent; }
  void set_ota_parent(OtaHttpRequestComponent *ota_parent) { this->ota_parent_ = ota_parent; }
@@ -62,21 +36,12 @@ class HttpRequestUpdate final : public update::UpdateEntity, public PollingCompo

  static void update_task(void *params);
 #ifdef USE_ESP32
-  TaskResult *task_result_{nullptr};  // set while a check runs on the update task
+  TaskHandle_t update_task_handle_{nullptr};
 #endif
  uint8_t initial_check_remaining_{0};

 private:
-  friend class testing::HttpRequestUpdateTest;
-  void release_source_url_();
-  // A check reads the URL it started with until it ends, on the update task or inline through an
-  // automation it triggers. Ownership of that buffer moves to the check, so a set_source_url in the
-  // meantime cannot free it; end_check_() hands it back or frees it on the main loop.
-  void begin_check_(TaskResult *result);
-  void end_check_(TaskResult *result);
-
-  bool source_url_owned_{false};  // source_url_ was copied by a run-time setter; sits in the padding above
-  const char *source_url_{nullptr};
+  const char *source_url_{nullptr};  // literal from codegen
 };

 }  // namespace esphome::http_request
@@ -52,7 +52,6 @@ ST7796.extend(
    height=480,
    offset_width=49,
    draw_rounding=1,
-    data_rate="40MHz",
    cs_pin=39,
    reset_pin=47,
    dc_pin=9,
@@ -1,5 +1,6 @@
 #include "download_buffer.h"
 #include "esphome/core/log.h"
+#include <algorithm>
 #include <cstring>

 namespace esphome::online_image {
@@ -34,6 +35,46 @@ size_t DownloadBuffer::read(size_t len) {
  return this->unread_;
 }

+void DownloadSource::compact() {
+  if (this->keep_read_ || this->pos_ == this->start_)
+    return;
+  this->buffer_.read(this->pos_ - this->start_);
+  this->start_ = this->pos_;
+}
+
+int32_t DownloadSource::read(uint8_t *buf, uint32_t len) {
+  const size_t offset = this->pos_ - this->start_;
+  const size_t n = std::min<size_t>(len, this->buffer_.unread() - offset);
+  memcpy(buf, this->buffer_.data(offset), n);
+  this->pos_ += n;
+  return static_cast<int32_t>(n);
+}
+
+bool DownloadSource::seek(uint32_t position) {
+  // Only what is still in the buffer can be read again; a decoder never skips ahead of the download
+  if (position < this->start_ || position > this->start_ + this->buffer_.unread())
+    return false;
+  this->pos_ = position;
+  return true;
+}
+
+bool DownloadBuffer::grow(size_t size) {
+  if (this->size_ >= size)
+    return true;
+  RAMAllocator<uint8_t> allocator;
+  uint8_t *buffer = allocator.allocate(size);
+  if (buffer == nullptr) {
+    ESP_LOGE(TAG, "allocation of %zu bytes failed. Biggest block in heap: %zu Bytes", size,
+             allocator.get_max_free_block_size());
+    return false;
+  }
+  memcpy(buffer, this->buffer_, this->unread_);
+  allocator.deallocate(this->buffer_, this->size_);
+  this->buffer_ = buffer;
+  this->size_ = size;
+  return true;
+}
+
 size_t DownloadBuffer::resize(size_t size) {
  if (this->size_ >= size) {
    // Avoid useless reallocations; if the buffer is big enough, don't reallocate.
@@ -1,5 +1,6 @@
 #pragma once

+#include "esphome/components/runtime_image/image_decoder.h"
 #include "esphome/core/helpers.h"
 #include <cstddef>
 #include <cstdint>
@@ -35,6 +36,8 @@ class DownloadBuffer {

  void reset() { this->unread_ = 0; }
  size_t resize(size_t size);
+  /// Make the buffer at least size bytes, keeping the unread data. Returns false if the allocation failed.
+  bool grow(size_t size);

 protected:
  uint8_t *buffer_;
@@ -43,4 +46,35 @@ class DownloadBuffer {
  size_t unread_;
 };

+/**
+ * @brief Lets a decoder read a download as it arrives, from the download buffer.
+ *
+ * The decoder reads at its own position in the buffer. Bytes it has read stay there until compact() drops
+ * them, and compact() keeps everything while set_keep_read(true) is in effect, so the decoder can seek back
+ * while it reads the headers.
+ */
+class DownloadSource : public runtime_image::DecodeSource {
+ public:
+  explicit DownloadSource(DownloadBuffer &buffer) : buffer_(buffer) {}
+
+  /// Start again at the beginning of a new download, keeping what is read
+  void reset() {
+    this->start_ = 0;
+    this->pos_ = 0;
+    this->keep_read_ = true;
+  }
+  void set_keep_read(bool keep) { this->keep_read_ = keep; }
+  /// Drop the bytes the decoder has read, to make room for more of the download
+  void compact();
+
+  int32_t read(uint8_t *buf, uint32_t len) override;
+  bool seek(uint32_t position) override;
+
+ protected:
+  DownloadBuffer &buffer_;
+  size_t start_{0};  // Position in the download of the first byte in the buffer
+  size_t pos_{0};    // Position in the download the decoder reads next
+  bool keep_read_{true};
+};
+
 }  // namespace esphome::online_image
@@ -22,6 +22,8 @@ DEPENDENCIES = ["http_request"]
 CODEOWNERS = ["@guillempages", "@clydebarrow"]

 CONF_ON_DOWNLOAD_FINISHED = "on_download_finished"
+CONF_ON_DOWNLOAD_STARTED = "on_download_started"
+CONF_ON_DOWNLOAD_PROGRESS = "on_download_progress"
 CONF_UPDATE = "update"

 online_image_ns = cg.esphome_ns.namespace("online_image")
@@ -43,7 +45,9 @@ ONLINE_IMAGE_SCHEMA = (
            cv.Optional(CONF_REQUEST_HEADERS): cv.All(
                cv.Schema({cv.string: cv.templatable(cv.string)})
            ),
+            cv.Optional(CONF_ON_DOWNLOAD_STARTED): automation.validate_automation({}),
            cv.Optional(CONF_ON_DOWNLOAD_FINISHED): automation.validate_automation({}),
+            cv.Optional(CONF_ON_DOWNLOAD_PROGRESS): automation.validate_automation({}),
            cv.Optional(CONF_ON_ERROR): automation.validate_automation({}),
        }
    )
@@ -96,9 +100,17 @@ automation.register_apply_action(


 _CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(
+        CONF_ON_DOWNLOAD_STARTED, "add_on_download_started_callback"
+    ),
    automation.CallbackAutomation(
        CONF_ON_DOWNLOAD_FINISHED, "add_on_finished_callback", [(bool, "cached")]
    ),
+    automation.CallbackAutomation(
+        CONF_ON_DOWNLOAD_PROGRESS,
+        "add_on_progress_callback",
+        [(float, "progress"), (cg.size_t, "bytes_read")],
+    ),
    automation.CallbackAutomation(CONF_ON_ERROR, "add_on_error_callback"),
 )

@@ -4,6 +4,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include <algorithm>
+#include <cmath>
 #include <cstdio>

 ESPHOME_LOG_TAG(TAG, "online_image");
@@ -15,6 +16,11 @@ static const char *const IF_MODIFIED_SINCE_HEADER_NAME = "if-modified-since";

 namespace esphome::online_image {

+// Time one loop pass may spend decoding a JPEG as it downloads
+static constexpr uint32_t STREAM_PASS_BUDGET_MS = 20;
+// Shortest time between two on_download_progress calls
+static constexpr uint32_t PROGRESS_INTERVAL_MS = 100;
+
 OnlineImage::OnlineImage(const std::string &url, int width, int height, runtime_image::ImageFormat format,
                         image::ImageType type, image::Transparency transparency, image::Image *placeholder,
                         uint32_t buffer_size, bool is_big_endian)
@@ -140,8 +146,12 @@ void OnlineImage::update() {
    return;
  }

-  // JPEG requires the complete image in the download buffer before decoding
-  if (format == runtime_image::JPEG && total_size > this->download_buffer_.size() &&
+  // A JPEG of known size is decoded as it arrives, so the download buffer only has to hold its headers.
+  // Otherwise the decoder needs the complete image in the buffer.
+  this->streaming_ = total_size > 0 && total_size <= INT32_MAX && this->decoder_supports_source();
+  this->stream_started_ = false;
+  this->source_.reset();
+  if (!this->streaming_ && format == runtime_image::JPEG && total_size > this->download_buffer_.size() &&
      this->download_buffer_.resize(total_size) == 0) {
    // resize() logged the failed allocation; the next update() allocates the configured buffer again
    this->end_connection_();
@@ -152,6 +162,8 @@ void OnlineImage::update() {
  ESP_LOGI(TAG, "Downloading image (Size: %zu)", total_size);
  this->start_time_ = millis();
  this->last_data_time_ = this->start_time_;
+  this->download_started_callback_.call();
+  this->report_progress_(true);
  this->enable_loop();
 }

@@ -169,6 +181,11 @@ void OnlineImage::loop() {
    return;
  }

+  if (this->streaming_) {
+    this->loop_stream_();
+    return;
+  }
+
  // Check if download is complete — use decoder's format-specific completion check
  // to handle both known content-length and chunked transfer encoding
  if (this->is_decode_finished() || (this->downloader_->content_length > 0 &&
@@ -188,6 +205,7 @@ void OnlineImage::loop() {
    if (len > 0) {
      this->last_data_time_ = App.get_loop_component_start_time();
      this->download_buffer_.write(len);
+      this->report_progress_(false);

      // Feed data to decoder
      auto consumed = this->feed_data(this->download_buffer_.data(), this->download_buffer_.unread());
@@ -255,6 +273,104 @@ void OnlineImage::loop() {
  }
 }

+void OnlineImage::loop_stream_() {
+  const uint32_t now = App.get_loop_component_start_time();
+  const size_t total = this->downloader_->content_length;
+  if (this->stream_started_)
+    this->source_.compact();
+
+  if (this->downloader_->get_bytes_read() < total) {
+    const size_t available = std::min(this->download_buffer_.free_capacity(), this->download_buffer_initial_size_);
+    if (available == 0) {
+      // Waiting for the decoder, not the network
+      this->last_data_time_ = now;
+    } else {
+      const int len = this->downloader_->read(this->download_buffer_.append(), available);
+      if (len > 0) {
+        this->last_data_time_ = now;
+        this->download_buffer_.write(len);
+        this->report_progress_(false);
+      } else if (len < 0) {
+        ESP_LOGE(TAG, "Error downloading image: %d", len);
+        this->fail_download_();
+        return;
+      } else if (now - this->last_data_time_ >= this->parent_->get_timeout()) {
+        ESP_LOGE(TAG, "No data received for %" PRIu32 " ms", this->parent_->get_timeout());
+        this->fail_download_();
+        return;
+      }
+    }
+  }
+  const bool arrived = this->downloader_->get_bytes_read() >= total;
+
+  if (!this->stream_started_) {
+    // The decoder reads the headers when it opens the image, so wait until they are in the buffer
+    if (!arrived && this->download_buffer_.free_capacity() != 0)
+      return;
+    const int err = this->begin_source(&this->source_);
+    if (err != 0) {
+      // Headers cut short by a full buffer fail to parse, or make the decoder seek past the buffer. Such an image
+      // still decodes once it is all in memory, as it did before JPEG images were decoded as they download.
+      if (!arrived && (err == runtime_image::DECODE_ERROR_INVALID_TYPE || err == runtime_image::DECODE_ERROR_READ)) {
+        ESP_LOGW(TAG,
+                 "The image headers do not fit the %zu byte download buffer, so the whole image is downloaded "
+                 "before it is decoded; increase buffer_size to decode it as it downloads",
+                 this->download_buffer_.size());
+        // grow() logs a failed allocation
+        if (this->download_buffer_.grow(total)) {
+          this->streaming_ = false;
+        } else {
+          this->fail_download_();
+        }
+        return;
+      }
+      ESP_LOGE(TAG, "Error decoding image: %s", runtime_image::decode_error_to_string(err));
+      this->fail_download_();
+      return;
+    }
+    this->source_.set_keep_read(false);
+    this->stream_started_ = true;
+    // Opening the image and allocating its buffer is enough for one pass
+    return;
+  }
+
+  do {
+    const int result = this->decode_step();
+    if (result == runtime_image::DECODE_STEP_MORE)
+      continue;
+    if (result == runtime_image::DECODE_STEP_DONE) {
+      this->finish_download_();
+    } else if (result == runtime_image::DECODE_STEP_NEED_DATA) {
+      if (!arrived)
+        return;
+      // JPEGDEC only waits for bytes short of the size it was given, so this guards against a hang
+      ESP_LOGE(TAG, "Download ended before the image was complete");
+      this->fail_download_();
+    } else {
+      ESP_LOGE(TAG, "Error decoding image: %s", runtime_image::decode_error_to_string(result));
+      this->fail_download_();
+    }
+    return;
+  } while (millis() - now < STREAM_PASS_BUDGET_MS);
+}
+
+void OnlineImage::report_progress_(bool force) {
+  const uint32_t now = App.get_loop_component_start_time();
+  const size_t bytes = this->downloader_->get_bytes_read();
+  const size_t total = this->downloader_->content_length;
+  // The last bytes are always reported, so a progress bar reaches 100%
+  if (!force && now - this->last_progress_time_ < PROGRESS_INTERVAL_MS && (total == 0 || bytes < total))
+    return;
+  this->last_progress_time_ = now;
+  const float progress = total > 0 ? std::min(100.0f, bytes * 100.0f / total) : NAN;
+  this->download_progress_callback_.call(progress, bytes);
+}
+
+void OnlineImage::fail_download_() {
+  this->end_connection_();
+  this->download_error_callback_.call();
+}
+
 void OnlineImage::finish_download_() {
  // Must be read before end_decode() ends the decoding session
  bool decoder_finished = this->is_decode_finished();
@@ -288,6 +404,8 @@ void OnlineImage::end_connection_() {
    this->downloader_ = nullptr;
  }
  this->download_buffer_.reset();
+  this->streaming_ = false;
+  this->stream_started_ = false;
  this->disable_loop();
 }

@@ -70,9 +70,17 @@ class OnlineImage final : public PollingComponent,
   */
  void release();

+  /// Called when the server has accepted the request and the image starts to download
+  template<typename F> void add_on_download_started_callback(F &&callback) {
+    this->download_started_callback_.add(std::forward<F>(callback));
+  }
  template<typename F> void add_on_finished_callback(F &&callback) {
    this->download_finished_callback_.add(std::forward<F>(callback));
  }
+  /// Called with the percentage downloaded (NAN when the server did not send the size) and the bytes read so far
+  template<typename F> void add_on_progress_callback(F &&callback) {
+    this->download_progress_callback_.add(std::forward<F>(callback));
+  }
  template<typename F> void add_on_error_callback(F &&callback) {
    this->download_error_callback_.add(std::forward<F>(callback));
  }
@@ -81,12 +89,20 @@ class OnlineImage final : public PollingComponent,
  bool validate_url_(const std::string &url);
  void end_connection_();
  void finish_download_();
+  /// loop() for a JPEG that is decoded as it downloads
+  void loop_stream_();
+  void fail_download_();
+  /// Reports download progress, at most every PROGRESS_INTERVAL_MS unless force is set
+  void report_progress_(bool force);

  CallbackManager<void(bool)> download_finished_callback_{};
  CallbackManager<void()> download_error_callback_{};
+  LazyCallbackManager<void()> download_started_callback_{};
+  LazyCallbackManager<void(float, size_t)> download_progress_callback_{};

  std::shared_ptr<http_request::HttpContainer> downloader_{nullptr};
  DownloadBuffer download_buffer_;
+  DownloadSource source_{download_buffer_};
  /**
   * This is the *initial* size of the download buffer, not the current size.
   * The download buffer can be resized at runtime; the download_buffer_initial_size_
@@ -109,6 +125,9 @@ class OnlineImage final : public PollingComponent,

  uint32_t start_time_{0};
  uint32_t last_data_time_{0};
+  uint32_t last_progress_time_{0};
+  bool streaming_{false};       // The decoder reads the download itself, as it arrives
+  bool stream_started_{false};  // The decoder has read the headers
 };

 }  // namespace esphome::online_image
@@ -92,7 +92,17 @@ class JPEGFormat(Format):

    def actions(self) -> None:
        cg.add_define("USE_RUNTIME_IMAGE_JPEG")
-        cg.add_library("JPEGDEC", "1.8.4", "https://github.com/bitbank2/JPEGDEC#1.8.4")
+        # 1.8.4 plus decodeBegin()/decodeRows(), so an image can be decoded a few rows at a time and
+        # can wait for input that has not arrived yet, and fixes for: input that arrives in short
+        # reads, garbled RGB8888 output of grayscale images, and two ARM NEON faults seen on arm64 hosts
+        # (swapped red and blue in the 4:2:0 RGB8888 path, writes past the row on clipped MCUs). It also
+        # uses the ESP32-S3 SIMD colour conversion in ESP-IDF builds, not only Arduino ones, and is built
+        # with -O2.
+        cg.add_library(
+            "JPEGDEC",
+            "1.8.4",
+            "https://github.com/esphome-libs/JPEGDEC#1.8.4-esphome.3",
+        )
        if CORE.is_host:
            # JPEGDEC's host detection checks __MACH__/__LINUX__, but gcc only
            # predefines the lowercase __linux__; without this a Linux host
@@ -2,7 +2,6 @@
 #include "runtime_image.h"
 #include "esphome/core/log.h"
 #include <algorithm>
-#include <cmath>

 namespace esphome::runtime_image {

@@ -11,19 +10,48 @@ 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;
-  this->x_scale_ = static_cast<double>(this->image_->get_buffer_width()) / width;
-  this->y_scale_ = static_cast<double>(this->image_->get_buffer_height()) / height;
+  this->draw_width_ = width;
+  this->draw_height_ = height;
  return success;
 }

+int ImageDecoder::scaled_x_(int x) const {
+  if (this->draw_width_ <= 0)
+    return 0;
+  const uint32_t buffer_width = this->image_->get_buffer_width();
+  return static_cast<int>((static_cast<uint32_t>(x) * buffer_width + this->draw_width_ - 1) / this->draw_width_);
+}
+
+int ImageDecoder::scaled_y_(int y) const {
+  if (this->draw_height_ <= 0)
+    return 0;
+  const uint32_t buffer_height = this->image_->get_buffer_height();
+  return static_cast<int>((static_cast<uint32_t>(y) * buffer_height + this->draw_height_ - 1) / this->draw_height_);
+}
+
 void ImageDecoder::draw(int x, int y, int w, int h, const Color &color) {
  if (!this->size_valid_) {
    return;
  }
-  auto width = std::min(this->image_->get_buffer_width(), static_cast<int>(std::ceil((x + w) * this->x_scale_)));
-  auto height = std::min(this->image_->get_buffer_height(), static_cast<int>(std::ceil((y + h) * this->y_scale_)));
-  for (int i = x * this->x_scale_; i < width; i++) {
-    for (int j = y * this->y_scale_; j < height; j++) {
+  // A source pixel paints the target pixels from ceil(start * scale) up to ceil(end * scale). The spans of neighbouring
+  // pixels meet without overlapping, so when an image is shrunk 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();
+  const int buffer_height = this->image_->get_buffer_height();
+  int x1 = x;
+  int y1 = y;
+  int x2 = x + w;
+  int y2 = y + h;
+  if (buffer_width != this->draw_width_ || buffer_height != this->draw_height_) {
+    x1 = this->scaled_x_(x);
+    y1 = this->scaled_y_(y);
+    x2 = this->scaled_x_(x + w);
+    y2 = this->scaled_y_(y + h);
+  }
+  x2 = std::min(buffer_width, x2);
+  y2 = std::min(buffer_height, y2);
+  for (int i = x1; i < x2; i++) {
+    for (int j = y1; j < y2; j++) {
      this->image_->draw_pixel(i, j, color);
    }
  }
@@ -1,4 +1,6 @@
 #pragma once
+#include <cstdint>
+
 #include "esphome/core/color.h"
 #include "image_format.h"

@@ -9,6 +11,14 @@ enum DecodeError : int {
  DECODE_ERROR_UNSUPPORTED_FORMAT = -2,
  DECODE_ERROR_OUT_OF_MEMORY = -3,
  DECODE_ERROR_INTERNAL_DECODER_ERROR = -4,
+  DECODE_ERROR_READ = -5,
+};
+
+/// Results of ImageDecoder::decode_step() other than a DecodeError
+enum DecodeStep : int {
+  DECODE_STEP_DONE = 0,
+  DECODE_STEP_MORE = 1,
+  DECODE_STEP_NEED_DATA = 2,  // The source has nothing more yet; call again once more has arrived
 };

 constexpr const char *decode_error_to_string(int error) {
@@ -21,6 +31,8 @@ constexpr const char *decode_error_to_string(int error) {
      return "Out of memory";
    case DECODE_ERROR_INTERNAL_DECODER_ERROR:
      return "Internal decoder error";
+    case DECODE_ERROR_READ:
+      return "Read error";
    default:
      return "Unknown error";
  }
@@ -28,6 +40,19 @@ constexpr const char *decode_error_to_string(int error) {

 class RuntimeImage;

+/// Input that a decoder reads itself as it goes, so the whole image never has to be in memory at once
+class DecodeSource {
+ public:
+  virtual ~DecodeSource() = default;
+  /**
+   * Read up to len bytes at the current position. Returns the number read, which is less than len, even 0, when
+   * no more has arrived yet or at the end of the input, or negative on error.
+   */
+  virtual int32_t read(uint8_t *buf, uint32_t len) = 0;
+  /// Move to a position counted from the start. Returns false on error.
+  virtual bool seek(uint32_t position) = 0;
+};
+
 /**
 * @brief Class to abstract decoding different image formats.
 */
@@ -58,8 +83,8 @@ class ImageDecoder {
    this->expected_size_ = 0;
    this->decoded_bytes_ = 0;
    this->size_valid_ = true;
-    this->x_scale_ = 1.0;
-    this->y_scale_ = 1.0;
+    this->draw_width_ = 0;
+    this->draw_height_ = 0;
  }

  /**
@@ -88,6 +113,28 @@ class ImageDecoder {
   */
  virtual int decode(uint8_t *buffer, size_t size) = 0;

+  /// Whether this decoder can read a DecodeSource itself, a step at a time, instead of being fed data.
+  virtual bool supports_source() const { return false; }
+
+  /**
+   * @brief Start decoding from a source the decoder reads itself. Call after prepare(), in place of decode().
+   *
+   * The image headers (everything before the image data) must be readable from the source when this is called;
+   * only decode_step() can wait for more to arrive. The source must hold expected_size bytes in the end, and stay
+   * valid until the session ends.
+   * @return int 0 on success, or a {@see DecodeError} value.
+   */
+  virtual int begin_source(DecodeSource *source) { return DECODE_ERROR_UNSUPPORTED_FORMAT; }
+
+  /**
+   * @brief Decode a little more of an image started with begin_source(), keeping each call short.
+   *
+   * @return int DECODE_STEP_MORE while there is more to do, DECODE_STEP_NEED_DATA when the source has not
+   *             delivered enough to go on, DECODE_STEP_DONE when the image is complete, or a {@see DecodeError}
+   *             value.
+   */
+  virtual int decode_step() { return DECODE_ERROR_UNSUPPORTED_FORMAT; }
+
  /**
   * @brief Request the image to be resized once the actual dimensions are known.
   * Called by the callback functions, to be able to access the parent Image class.
@@ -112,6 +159,9 @@ class ImageDecoder {
   */
  void draw(int x, int y, int w, int h, const Color &color);

+  /// Bytes of the image the decoder has used so far
+  size_t get_decoded_bytes() const { return this->decoded_bytes_; }
+
  /**
   * @brief Check if the decoder has finished processing.
   *
@@ -134,8 +184,13 @@ class ImageDecoder {
  uint8_t *image_buffer_() const;
  bool image_is_big_endian_() const;

-  double x_scale_ = 1.0;
-  double y_scale_ = 1.0;
+  /// The first buffer column, or row, that source column x, or row y, paints: ceil(x * buffer size / draw size)
+  int scaled_x_(int x) const;
+  int scaled_y_(int y) const;
+
+  // Size of the image as the decoder draws it, which draw() spreads over the buffer
+  int draw_width_ = 0;
+  int draw_height_ = 0;
  RuntimeImage *image_;
  size_t expected_size_ = 0;  // Expected data size (0 if unknown)
  size_t decoded_bytes_ = 0;  // Bytes processed so far
@@ -31,8 +31,8 @@ bool JpegDecoder::prepare_rgb565_scaling_(int width, int height) {
  const uint32_t target_width = this->image_->get_buffer_width();
  const uint32_t target_height = this->image_->get_buffer_height();
  // Boundary n is the first target pixel source pixel n covers, rounded up. When shrinking, the source
-  // pixel whose span lands on a target pixel paints it, so an 8 to 4 scale keeps columns 0, 2, 4 and 6;
-  // the generic draw() path rounds down and keeps the odd ones instead
+  // pixel whose span lands on a target pixel paints it, so an 8 to 4 scale keeps columns 0, 2, 4 and 6,
+  // as the generic draw() path does
  for (uint32_t x = 0; x <= static_cast<uint32_t>(width); x++) {
    this->x_boundaries_.push_back(static_cast<uint16_t>((x * target_width + width - 1) / width));
  }
@@ -135,13 +135,24 @@ int HOT JpegDecoder::decode(uint8_t *buffer, size_t size) {
    ESP_LOGE(TAG, "Could not open image for decoding: %d", this->jpeg_.getLastError());
    return DECODE_ERROR_INVALID_TYPE;
  }
+  const int err = this->start_();
+  if (err != 0)
+    return err;
+  if (!this->jpeg_.decode(0, 0, this->scale_option_()))
+    return this->fail_();
+  this->decoded_bytes_ = size;
+  this->jpeg_.close();
+  return size;
+}
+
+int JpegDecoder::start_() {
  auto jpeg_type = this->jpeg_.getJPEGType();
  if (jpeg_type == JPEG_MODE_INVALID) {
    ESP_LOGE(TAG, "Unsupported JPEG image");
    return DECODE_ERROR_INVALID_TYPE;
  } else if (jpeg_type == JPEG_MODE_PROGRESSIVE) {
    ESP_LOGE(TAG, "Progressive JPEG images not supported");
-    return DECODE_ERROR_INVALID_TYPE;
+    return DECODE_ERROR_UNSUPPORTED_FORMAT;
  }
  ESP_LOGD(TAG, "Image size: %d x %d, bpp: %d", this->jpeg_.getWidth(), this->jpeg_.getHeight(), this->jpeg_.getBpp());

@@ -154,32 +165,133 @@ int HOT JpegDecoder::decode(uint8_t *buffer, size_t size) {
  } else {
    this->jpeg_.setPixelType(RGB8888);
  }
-  if (!this->set_size(this->jpeg_.getWidth(), this->jpeg_.getHeight())) {
+  const int width = this->jpeg_.getWidth();
+  const int height = this->jpeg_.getHeight();
+  if (!this->set_size(width, height)) {
    return DECODE_ERROR_OUT_OF_MEMORY;
  }
-  if (this->direct_rgb565_ && !this->prepare_rgb565_scaling_(this->jpeg_.getWidth(), this->jpeg_.getHeight())) {
+  // 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
+  // many pixels as the buffer, so a large image shown small is not decoded in full only to be thrown away.
+  const int buffer_width = this->image_->get_buffer_width();
+  const int buffer_height = this->image_->get_buffer_height();
+  this->scale_ = 1;
+  while (this->scale_ < JPEG_SCALE_EIGHTH && width / (this->scale_ * 2) >= buffer_width &&
+         height / (this->scale_ * 2) >= buffer_height) {
+    this->scale_ *= 2;
+  }
+  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;
  }
-  if (!this->jpeg_.decode(0, 0, 0)) {
-    auto error = this->jpeg_.getLastError();
-    ESP_LOGE(TAG, "Error while decoding: %d", error);
-    this->jpeg_.close();
-    switch (error) {
-      case JPEG_ERROR_MEMORY:
-        return DECODE_ERROR_OUT_OF_MEMORY;
-      case JPEG_UNSUPPORTED_FEATURE:
-        return DECODE_ERROR_UNSUPPORTED_FORMAT;
-      case JPEG_INVALID_FILE:
-      case JPEG_INVALID_PARAMETER:
-        return DECODE_ERROR_INVALID_TYPE;
-      case JPEG_DECODE_ERROR:
-      default:
-        return DECODE_ERROR_INTERNAL_DECODER_ERROR;
-    }
-  }
-  this->decoded_bytes_ = size;
+  return 0;
+}
+
+int JpegDecoder::fail_() {
+  const bool read_failed = this->source_ != nullptr && this->source_failed_;
+  const int error = this->jpeg_.getLastError();
  this->jpeg_.close();
-  return size;
+  this->source_ = nullptr;
+  if (read_failed) {
+    ESP_LOGE(TAG, "Reading the image failed");
+    return DECODE_ERROR_READ;
+  }
+  ESP_LOGE(TAG, "Error while decoding: %d", error);
+  switch (error) {
+    case JPEG_ERROR_MEMORY:
+      return DECODE_ERROR_OUT_OF_MEMORY;
+    case JPEG_UNSUPPORTED_FEATURE:
+      return DECODE_ERROR_UNSUPPORTED_FORMAT;
+    case JPEG_INVALID_FILE:
+    case JPEG_INVALID_PARAMETER:
+      return DECODE_ERROR_INVALID_TYPE;
+    case JPEG_DECODE_ERROR:
+    default:
+      return DECODE_ERROR_INTERNAL_DECODER_ERROR;
+  }
+}
+
+void JpegDecoder::reset() {
+  // A decode from a source that was given up part way still has the image open
+  if (this->source_ != nullptr) {
+    this->jpeg_.close();
+    this->source_ = nullptr;
+  }
+  ImageDecoder::reset();
+}
+
+int32_t JpegDecoder::source_read(JPEGFILE *file, uint8_t *buf, int32_t len) {
+  auto *decoder = static_cast<JpegDecoder *>(file->fHandle);
+  const int32_t n = decoder->source_->read(buf, len);
+  if (n < 0) {
+    // JPEGDEC has no way to report a failed read, so remember it and give it no data
+    decoder->source_failed_ = true;
+    return 0;
+  }
+  file->iPos += n;
+  return n;
+}
+
+int32_t JpegDecoder::source_seek(JPEGFILE *file, int32_t position) {
+  auto *decoder = static_cast<JpegDecoder *>(file->fHandle);
+  if (position < 0 || !decoder->source_->seek(position)) {
+    decoder->source_failed_ = true;
+    return file->iPos;
+  }
+  file->iPos = position;
+  return position;
+}
+
+int JpegDecoder::begin_source(DecodeSource *source) {
+  if (this->expected_size_ == 0 || this->expected_size_ > INT32_MAX) {
+    ESP_LOGE(TAG, "Image size %zu cannot be read from a source", this->expected_size_);
+    return DECODE_ERROR_INVALID_TYPE;
+  }
+  if (!source->seek(0)) {
+    ESP_LOGE(TAG, "Could not read the image");
+    return DECODE_ERROR_READ;
+  }
+  this->source_ = source;
+  this->source_failed_ = false;
+  if (!this->jpeg_.open(this, this->expected_size_, source_close, source_read, source_seek, draw_callback)) {
+    // The caller may recover, for example by reading the whole image first, so it reports the failure
+    ESP_LOGD(TAG, "Could not open image for decoding: %d", this->jpeg_.getLastError());
+    this->source_ = nullptr;
+    return this->source_failed_ ? DECODE_ERROR_READ : DECODE_ERROR_INVALID_TYPE;
+  }
+  const int err = this->start_();
+  if (err != 0) {
+    this->jpeg_.close();
+    this->source_ = nullptr;
+    return err;
+  }
+  if (!this->jpeg_.decodeBegin(0, 0, this->scale_option_()))
+    return this->fail_();
+  return 0;
+}
+
+int HOT JpegDecoder::decode_step() {
+  if (this->source_ == nullptr)
+    return DECODE_ERROR_INVALID_TYPE;
+  const int result = this->jpeg_.decodeRows(1);
+  // JPEGDEC may decode on with the missing data, so check the read before its result
+  if (this->source_failed_)
+    return this->fail_();
+  if (result == JPEG_DECODE_MORE)
+    return DECODE_STEP_MORE;
+  if (result == JPEG_DECODE_NEED_DATA)
+    return DECODE_STEP_NEED_DATA;
+  if (result == 0)
+    return this->fail_();
+  this->decoded_bytes_ = this->expected_size_;
+  this->jpeg_.close();
+  this->source_ = nullptr;
+  return DECODE_STEP_DONE;
 }

 }  // namespace esphome::runtime_image
@@ -22,19 +22,41 @@ class JpegDecoder : public ImageDecoder {
  ~JpegDecoder() override {}

  int HOT decode(uint8_t *buffer, size_t size) override;
+  void reset() override;
+
+  /// The source is read as the decode needs it, through JPEGDEC's own 2 KB buffer
+  bool supports_source() const override { return true; }
+  int begin_source(DecodeSource *source) override;
+  /// 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
+  int scale_option_() const { return this->scale_ == 1 ? 0 : this->scale_; }
+  /// The DecodeError for a failed read of the source or JPEGDEC's last error, closing the image
+  int fail_();
+
+  static int32_t source_read(JPEGFILE *file, uint8_t *buf, int32_t len);
+  static int32_t source_seek(JPEGFILE *file, int32_t position);
+  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};
 };

 }  // namespace esphome::runtime_image
@@ -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;
@@ -239,6 +241,25 @@ int RuntimeImage::feed_data(uint8_t *data, size_t len) {
  return consumed;
 }

+int RuntimeImage::begin_source(DecodeSource *source) {
+  if (!this->decoder_supports_source()) {
+    ESP_LOGE(TAG, "Decoder cannot read a source");
+    return DECODE_ERROR_UNSUPPORTED_FORMAT;
+  }
+  return this->decoder_->begin_source(source);
+}
+
+int RuntimeImage::decode_step() {
+  if (!this->is_decoding()) {
+    ESP_LOGE(TAG, "No decoder initialized");
+    return DECODE_ERROR_INVALID_TYPE;
+  }
+  const int result = this->decoder_->decode_step();
+  if (result == DECODE_STEP_DONE)
+    this->decoded_bytes_ = this->decoder_->get_decoded_bytes();
+  return result;
+}
+
 bool RuntimeImage::end_decode() {
  if (!this->is_decoding()) {
    return false;
@@ -76,6 +76,22 @@ class RuntimeImage : public image::Image {
   */
  int feed_data(uint8_t *data, size_t len);

+  /// Whether the active decoder can read a DecodeSource itself (see begin_source()).
+  bool decoder_supports_source() const { return this->is_decoding() && this->decoder_->supports_source(); }
+
+  /**
+   * @brief Decode from a source the decoder reads itself, in place of feed_data().
+   *
+   * Call after begin_decode() when decoder_supports_source() is true, once the image headers can be read from the
+   * source, then call decode_step() until it
+   * returns DECODE_STEP_DONE, and finish with end_decode().
+   * @return 0 on success, or a DecodeError value.
+   */
+  int begin_source(DecodeSource *source);
+
+  /// Decode a little more from the source; see ImageDecoder::decode_step().
+  int decode_step();
+
  /**
   * @brief Complete the decoding process.
   *
@@ -351,7 +351,6 @@
 #define USE_API_USER_DEFINED_ACTIONS
 #define USE_API_CUSTOM_SERVICES
 #define USE_API_USER_DEFINED_ACTION_METADATA
-#define USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
 #define USE_API_USER_DEFINED_ACTION_RESPONSES
 #define USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
 #define API_MAX_SEND_QUEUE 8
@@ -48,7 +48,7 @@ lib_deps =
    improv/Improv@1.2.7                    ; improv_serial / improv_ble
    kikuchan98/pngle@1.1.0                 ; runtime_image
    ; Using the repository directly, otherwise ESP-IDF can't use the library
-    https://github.com/bitbank2/JPEGDEC.git#1.8.4    ; runtime_image
+    https://github.com/esphome-libs/JPEGDEC.git#1.8.4-esphome.3    ; runtime_image
    ; This dependency is used only in unit tests.
    ; Must coincide with PLATFORMIO_GOOGLE_TEST_LIB in scripts/cpp_unit_test.py
    ; See scripts/cpp_unit_test.py and tests/components/README.md
@@ -253,7 +253,7 @@ lib_deps =
    heman/AsyncMqttClient-esphome@2.0.0   ; mqtt
    improv/Improv@1.2.7                   ; improv_serial
    kikuchan98/pngle@1.1.0                ; runtime_image
-    https://github.com/bitbank2/JPEGDEC.git#1.8.4    ; runtime_image
+    https://github.com/esphome-libs/JPEGDEC.git#1.8.4-esphome.3    ; runtime_image
 build_flags =
    ${common:arduino.build_flags}
    -DUSE_LIBRETINY
@@ -12,7 +12,7 @@ pyserial==3.5
 platformio==6.2.0
 esptool==5.6.0
 click==8.5.0
-aioesphomeapi==46.21.0
+aioesphomeapi==46.20.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
 zeroconf==0.151.5
 puremagic==2.2.0
@@ -112,7 +112,7 @@ def test_empty_metadata_is_unset() -> None:
        "description": "",
        "variables": {"b": {"type": "int", "description": "", "example": "ex"}},
    }
-    strings = _action_strings(conf, has_metadata=True, has_optional=False)
+    strings = _action_strings(conf, has_metadata=True)
    assert strings == ["a", None, "b", None, "ex"]


@@ -1,158 +0,0 @@
-"""Tests for optional user-defined action variables (required/default)."""
-
-from collections.abc import Callable
-from pathlib import Path
-import re
-
-import pytest
-
-from esphome.components.api import (
-    _action_strings,
-    _has_optional_args,
-    validate_variable,
-)
-from esphome.config_validation import Invalid
-from esphome.core import CORE
-
-CONFIG = "tests/component_tests/api/test_action_optional_args.yaml"
-CONFIG_ESP8266 = "tests/component_tests/api/test_action_optional_args_esp8266.yaml"
-CONFIG_SHORTHAND = "tests/component_tests/api/test_action_metadata_shorthand.yaml"
-
-
-def test_defaults_are_emitted_in_the_string_table(
-    generate_main: Callable[[str | Path], str],
-) -> None:
-    """Each argument gains a trailing default slot: "" marks optional without a default."""
-    main_cpp = generate_main(CONFIG)
-
-    assert (
-        "static constexpr const char * api_action0_strings[] PROGMEM = {"
-        '"play_buzzer", "song_str", "", "notes", "", "octave", "5", '
-        '"bpm", "100", "loud", "true"};' in main_cpp
-    )
-    # An all-required action still carries the default slots (as nullptr)
-    assert (
-        "static constexpr const char * api_action1_strings[] PROGMEM = {"
-        '"plain_action", "value", nullptr};' in main_cpp
-    )
-    assert "USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS" in {d.name for d in CORE.defines}
-
-
-def test_esp8266_defaults_are_progmem_arrays(
-    generate_main: Callable[[str | Path], str],
-) -> None:
-    """On ESP8266 each default is its own PROGMEM array, referenced from the table."""
-    main_cpp = generate_main(CONFIG_ESP8266)
-
-    def array_for(text: str) -> str:
-        match = re.search(
-            rf'static constexpr char (progmem_str\w*)\[\] PROGMEM = "{text}";', main_cpp
-        )
-        assert match, text
-        return match.group(1)
-
-    assert (
-        "static constexpr const char * api_action0_strings[] PROGMEM = {"
-        f"{array_for('play_buzzer')}, {array_for('song_str')}, {array_for('')}, "
-        f"{array_for('notes')}, {array_for('')}, {array_for('octave')}, {array_for('5')}, "
-        f"{array_for('bpm')}, {array_for('100')}, {array_for('loud')}, "
-        f"{array_for('true')}}};" in main_cpp
-    )
-
-
-def test_required_variables_emit_no_define(
-    generate_main: Callable[[str | Path], str],
-) -> None:
-    generate_main(CONFIG_SHORTHAND)
-
-    assert "USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS" not in {
-        d.name for d in CORE.defines
-    }
-
-
-def test_action_strings_orders_default_after_metadata() -> None:
-    conf = {
-        "action": "a",
-        "description": "d",
-        "variables": {
-            "b": {"type": "int", "example": "1", "default": 5},
-            "c": {"type": "bool", "default": False},
-        },
-    }
-    assert _action_strings(conf, has_metadata=True, has_optional=True) == [
-        "a",
-        "d",
-        "b",
-        None,
-        "1",
-        "5",
-        "c",
-        None,
-        None,
-        "false",
-    ]
-
-
-@pytest.mark.parametrize(
-    ("var", "expected"),
-    [
-        ({"type": "int", "required": False}, ""),
-        ({"type": "string", "default": ""}, ""),
-        ({"type": "float", "default": 5}, "5.0"),
-    ],
-)
-def test_default_slot_marks_optional_and_keeps_the_type(
-    var: dict, expected: str
-) -> None:
-    actions = [{"action": "a", "variables": {"b": validate_variable(var)}}]
-    assert _has_optional_args(actions)
-    assert _action_strings(actions[0], has_metadata=False, has_optional=True) == [
-        "a",
-        "b",
-        expected,
-    ]
-
-
-@pytest.mark.parametrize(
-    ("var", "expected"),
-    [
-        ({"type": "int", "default": "5"}, 5),
-        ({"type": "int", "default": -(2**31)}, -(2**31)),
-        ({"type": "int", "default": 2**31 - 1}, 2**31 - 1),
-        ({"type": "bool", "default": "true"}, True),
-        ({"type": "float", "default": "1.5"}, 1.5),
-        ({"type": "float", "default": 3.4028235e38}, 3.4028235e38),
-        ({"type": "string", "default": "0123"}, "0123"),
-    ],
-)
-def test_default_is_validated_against_type(var: dict, expected: object) -> None:
-    assert validate_variable(var)["default"] == expected
-
-
-@pytest.mark.parametrize(
-    "var",
-    [
-        {"type": "int[]", "required": False},
-        {"type": "string[]", "default": "x"},
-        {"type": "int", "default": 5, "required": True},
-        {"type": "int", "default": "not_a_number"},
-        # ExecuteServiceArgument.int_ is a signed 32-bit value
-        {"type": "int", "default": 2**31},
-        {"type": "int", "default": -(2**31) - 1},
-        # A boolean is an int in Python but "true" is not a number on the wire
-        {"type": "int", "default": True},
-        {"type": "float", "default": False},
-        # ExecuteServiceArgument.float_ is a 32-bit float
-        {"type": "float", "default": 1e40},
-        {"type": "float", "default": "nan"},
-        {"type": "float", "default": "inf"},
-        # A string default is what the user typed, and a C string in flash
-        {"type": "string", "default": 123},
-        {"type": "string", "default": "a\0b"},
-        {"type": "string", "default": "\0a"},
-        {"type": "float", "default": -1e40},
-    ],
-)
-def test_variable_rejects_invalid_optionality(var: dict) -> None:
-    with pytest.raises(Invalid):
-        validate_variable(var)
@@ -1,14 +0,0 @@
-esphome:
-  name: test
-
-esp32:
-  board: esp32dev
-
-wifi:
-  ssid: MySSID
-  password: password1
-
-logger:
-
-packages:
-  api: !include test_action_optional_args_common.yaml
@@ -1,26 +0,0 @@
-api:
-  actions:
-    - action: play_buzzer
-      variables:
-        song_str:
-          type: string
-          required: false
-        notes:
-          type: string
-          required: false
-        octave:
-          type: int
-          default: 5
-        bpm:
-          type: int
-          default: 100
-        loud:
-          type: bool
-          default: true
-      then:
-        - logger.log: Action Called
-    - action: plain_action
-      variables:
-        value: int
-      then:
-        - logger.log: Action Called
@@ -1,14 +0,0 @@
-esphome:
-  name: test
-
-esp8266:
-  board: d1_mini
-
-wifi:
-  ssid: MySSID
-  password: password1
-
-logger:
-
-packages:
-  api: !include test_action_optional_args_common.yaml
@@ -78,7 +78,6 @@ api:
          type: string
          description: Name to greet
          example: World
-          default: World
      then:
        - logger.log:
            format: Hello World %s!
@@ -57,21 +57,6 @@ button:
            url: !lambda 'return std::string("http://my.ha.net:8123/local/esphome/firmware.bin");'

        - logger.log: "This message should be not displayed (reboot)"
-  # Device firmware switches the manifest from lambdas; every shape below must compile and
-  # the stored URL must outlive the lambda (EverythingSmartHome/everything-presence-one#341).
-  - platform: template
-    name: Switch manifest
-    on_press:
-      then:
-        - lambda: |-
-            id(ota_update).set_source_url("http://my.ha.net:8123/local/esphome/beta-manifest.json");
-            std::string url = "http://my.ha.net:8123/local/esphome/";
-            url += "manifest.json";
-            id(ota_update).set_source_url(url);
-            id(ota_update).set_source_url(url.c_str());
-            id(ota_update).set_source_url(std::string("http://my.ha.net:8123/local/esphome/manifest.json"));
-            ESP_LOGI("test", "Manifest is now %s", id(ota_update).get_source_url());
-        - component.update: ota_update

 update:
  - platform: http_request
@@ -1,8 +0,0 @@
-import esphome.config_validation as cv
-from tests.testing_helpers import ComponentManifestOverride
-
-
-def override_manifest(manifest: ComponentManifestOverride) -> None:
-    # The real schema rejects the host target by framework version; the update platform's
-    # unit tests only need this platform's sources on the host.
-    manifest.config_schema = cv.Schema({}, extra=cv.ALLOW_EXTRA)
@@ -1,141 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <string>
-
-#include "esphome/components/http_request/update/http_request_update.h"
-
-#if defined(__SANITIZE_ADDRESS__)
-#define HAS_ASAN
-#elif defined(__has_feature)
-#if __has_feature(address_sanitizer)
-#define HAS_ASAN
-#endif
-#endif
-#ifdef HAS_ASAN
-#include <sanitizer/asan_interface.h>
-#endif
-
-namespace esphome::http_request::testing {
-
-namespace {
-
-constexpr char LITERAL[] = "http://example.invalid/manifest.json";
-
-// Freed heap memory is poisoned under AddressSanitizer, which CI builds with; without it the
-// freed-exactly-once checks cannot be observed and are skipped.
-void expect_freed(const char *buffer) {
-#ifdef HAS_ASAN
-  EXPECT_TRUE(__asan_address_is_poisoned(buffer));
-#endif
-}
-
-void expect_live(const char *buffer, const char *content) {
-#ifdef HAS_ASAN
-  EXPECT_FALSE(__asan_address_is_poisoned(buffer));
-#endif
-  EXPECT_STREQ(buffer, content);
-}
-
-}  // namespace
-
-// Friend of HttpRequestUpdate, so a check can be begun and ended without an HTTP fetch.
-class HttpRequestUpdateTest : public ::testing::Test {
- protected:
-  static void begin_check(HttpRequestUpdate &update, TaskResult &result) { update.begin_check_(&result); }
-  static void end_check(HttpRequestUpdate &update, TaskResult &result) { update.end_check_(&result); }
-};
-
-TEST(HttpRequestUpdateSourceUrl, ConfigLiteralIsKeptByPointer) {
-  HttpRequestUpdate update;
-  update.set_source_url_static(LITERAL);
-  EXPECT_EQ(update.get_source_url(), LITERAL);
-}
-
-TEST(HttpRequestUpdateSourceUrl, RuntimeStringIsCopied) {
-  HttpRequestUpdate update;
-  std::string url = "http://example.invalid/from-string-manifest.json";
-  update.set_source_url(url);
-  EXPECT_NE(update.get_source_url(), url.c_str());
-  EXPECT_STREQ(update.get_source_url(), url.c_str());
-}
-
-// Device firmware passes base_url.c_str() of a local and runs the update after the lambda returned.
-TEST(HttpRequestUpdateSourceUrl, PointerIntoDeadLocalStaysReadable) {
-  HttpRequestUpdate update;
-  {
-    std::string local = "http://example.invalid/from-local-manifest.json";
-    update.set_source_url(local.c_str());
-  }
-  EXPECT_STREQ(update.get_source_url(), "http://example.invalid/from-local-manifest.json");
-}
-
-TEST(HttpRequestUpdateSourceUrl, PassingTheCurrentUrlBackIsSafe) {
-  HttpRequestUpdate update;
-  update.set_source_url("http://example.invalid/current-manifest.json");
-  const char *previous = update.get_source_url();
-  update.set_source_url(update.get_source_url());
-  EXPECT_STREQ(update.get_source_url(), "http://example.invalid/current-manifest.json");
-  expect_freed(previous);
-}
-
-TEST(HttpRequestUpdateSourceUrl, ConfigLiteralAfterRuntimeUrlDropsTheCopy) {
-  HttpRequestUpdate update;
-  update.set_source_url("http://example.invalid/runtime-manifest.json");
-  const char *copy = update.get_source_url();
-  update.set_source_url_static(LITERAL);
-  EXPECT_EQ(update.get_source_url(), LITERAL);
-  expect_freed(copy);
-}
-
-// The URL a check started with stays readable until the check ends, however often it is replaced in
-// the meantime; the replacements it never saw are freed at once and the original exactly once.
-TEST_F(HttpRequestUpdateTest, UrlReplacedDuringACheckOutlivesIt) {
-  HttpRequestUpdate update;
-  update.set_source_url("http://example.invalid/first-manifest.json");
-  const char *first = update.get_source_url();
-  TaskResult result;
-  begin_check(update, result);
-  EXPECT_EQ(result.source_url, first);
-
-  update.set_source_url("http://example.invalid/second-manifest.json");
-  const char *second = update.get_source_url();
-  expect_live(first, "http://example.invalid/first-manifest.json");
-
-  update.set_source_url("http://example.invalid/third-manifest.json");
-  const char *third = update.get_source_url();
-  expect_live(first, "http://example.invalid/first-manifest.json");
-  expect_freed(second);
-
-  end_check(update, result);
-  expect_freed(first);
-  expect_live(third, "http://example.invalid/third-manifest.json");
-  // The entity owns the URL set during the check: switching away frees it.
-  update.set_source_url_static(LITERAL);
-  expect_freed(third);
-}
-
-TEST_F(HttpRequestUpdateTest, UrlUnchangedDuringACheckReturnsToTheEntity) {
-  HttpRequestUpdate update;
-  update.set_source_url("http://example.invalid/kept-manifest.json");
-  const char *kept = update.get_source_url();
-  TaskResult result;
-  begin_check(update, result);
-  end_check(update, result);
-  expect_live(kept, "http://example.invalid/kept-manifest.json");
-  // Ownership came back, so the next change frees it instead of leaking it.
-  update.set_source_url_static(LITERAL);
-  expect_freed(kept);
-}
-
-TEST_F(HttpRequestUpdateTest, ConfigLiteralDuringACheckIsNeverFreed) {
-  HttpRequestUpdate update;
-  update.set_source_url_static(LITERAL);
-  TaskResult result;
-  begin_check(update, result);
-  update.set_source_url("http://example.invalid/runtime-manifest.json");
-  end_check(update, result);
-  EXPECT_STREQ(LITERAL, "http://example.invalid/manifest.json");
-  EXPECT_STREQ(update.get_source_url(), "http://example.invalid/runtime-manifest.json");
-}
-
-}  // namespace esphome::http_request::testing
@@ -1,11 +0,0 @@
-import esphome.codegen as cg
-from tests.testing_helpers import ComponentManifestOverride
-
-
-def override_manifest(manifest: ComponentManifestOverride) -> None:
-    # setup() registers the entity as an OTA state listener, which the real to_code
-    # requests through ota.request_ota_state_listeners().
-    async def to_code_testing(config):
-        cg.add_define("USE_OTA_STATE_LISTENER")
-
-    manifest.to_code = to_code_testing
@@ -19,6 +19,11 @@ image:
        } else {
          ESP_LOGD("online_image", "Cache miss: fresh download");
        }
+    on_download_started:
+      - logger.log: Download started
+    on_download_progress:
+      lambda: |-
+        ESP_LOGD("online_image", "Downloaded %.0f%% (%zu bytes)", progress, bytes_read);
  - platform: online_image
    id: online_binary_transparent_image
    url: http://www.libpng.org/pub/png/img_png/pnglogo-blk-tiny.png
@@ -2,6 +2,7 @@

 #include <algorithm>
 #include <array>
+#include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <memory>
@@ -27,6 +28,8 @@ class FakeContainer : public http_request::HttpContainer {
  }

  int read(uint8_t *buf, size_t max_len) override {
+    if (this->read_error_)
+      return -1;
    size_t len = std::min(max_len, this->available_ - this->bytes_read_);
    std::memcpy(buf, this->body_.data() + this->bytes_read_, len);
    this->bytes_read_ += len;
@@ -42,6 +45,10 @@ class FakeContainer : public http_request::HttpContainer {
  }

  void set_content_length(size_t length) { this->content_length = length; }
+  /// Make every read from now on fail, like a dropped connection
+  void fail_reads() { this->read_error_ = true; }
+  /// Let len more bytes of the body arrive
+  void deliver(size_t len) { this->available_ = std::min(this->body_.size(), this->available_ + len); }
  void add_response_header(const std::string &name, const std::string &value) {
    this->response_headers_.push_back({name, value});
  }
@@ -49,6 +56,7 @@ class FakeContainer : public http_request::HttpContainer {
 protected:
  std::vector<uint8_t> body_;
  size_t available_;
+  bool read_error_{false};
 };

 class FakeHttpRequest : public http_request::HttpRequestComponent {
@@ -123,13 +131,173 @@ 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};

+// 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,
+    0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x10, 0x0B, 0x0C, 0x0E, 0x0C, 0x0A, 0x10, 0x0E, 0x0D, 0x0E, 0x12, 0x11, 0x10,
+    0x13, 0x18, 0x28, 0x1A, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25, 0x1D, 0x28, 0x3A, 0x33, 0x3D, 0x3C, 0x39, 0x33,
+    0x38, 0x37, 0x40, 0x48, 0x5C, 0x4E, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6D, 0x51, 0x57, 0x5F, 0x62, 0x67,
+    0x68, 0x67, 0x3E, 0x4D, 0x71, 0x79, 0x70, 0x64, 0x78, 0x5C, 0x65, 0x67, 0x63, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x11,
+    0x12, 0x12, 0x18, 0x15, 0x18, 0x2F, 0x1A, 0x1A, 0x2F, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0xFF, 0xC2, 0x00, 0x11, 0x08, 0x00, 0x08, 0x00, 0x08, 0x03, 0x01, 0x22, 0x00,
+    0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x15, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xFF, 0xC4, 0x00, 0x15, 0x01, 0x01, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0xFF, 0xDA, 0x00, 0x0C, 0x03,
+    0x01, 0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00, 0x01, 0x94, 0x05, 0x3F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x01, 0x05, 0x02, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3F,
+    0x01, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3F, 0x01, 0x7F, 0xFF, 0xC4, 0x00,
+    0x14, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0xDA, 0x00, 0x08, 0x01, 0x01, 0x00, 0x06, 0x3F, 0x02, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x01, 0x3F, 0x21, 0x7F, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x10, 0x0B, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xC4, 0x00,
+    0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0xDA, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xD9,
+};
+
+// 48x40 4:2:0 JPEG (quality 95), 2344 bytes: three rows of 16 pixel MCUs, with the scan starting at byte 609
+static const uint8_t JPEG_48X40[] = {
+    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+    0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,
+    0x02, 0x02, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x05, 0x04, 0x04, 0x03, 0x04, 0x06, 0x05, 0x06, 0x06, 0x06, 0x05,
+    0x06, 0x06, 0x06, 0x07, 0x09, 0x08, 0x06, 0x07, 0x09, 0x07, 0x06, 0x06, 0x08, 0x0B, 0x08, 0x09, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x06, 0x08, 0x0B, 0x0C, 0x0B, 0x0A, 0x0C, 0x09, 0x0A, 0x0A, 0x0A, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x02,
+    0x02, 0x02, 0x02, 0x02, 0x02, 0x05, 0x03, 0x03, 0x05, 0x0A, 0x07, 0x06, 0x07, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x28, 0x00, 0x30, 0x03, 0x01, 0x22, 0x00,
+    0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+    0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00,
+    0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62,
+    0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37,
+    0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A,
+    0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85,
+    0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
+    0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
+    0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
+    0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00,
+    0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
+    0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04,
+    0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,
+    0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09,
+    0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A,
+    0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
+    0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75,
+    0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
+    0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
+    0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
+    0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
+    0xFA, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3F, 0x00, 0xFC, 0xAA, 0xB8, 0xB7,
+    0xD3, 0xB5, 0xD8, 0x1E, 0xD6, 0xD1, 0xA5, 0x5B, 0x4B, 0x46, 0x10, 0xC1, 0x06, 0xA1, 0x29, 0x69, 0x25, 0xB7, 0xC2,
+    0xC6, 0x0C, 0x71, 0x26, 0x5E, 0x50, 0x15, 0x5D, 0xB6, 0x9C, 0x9E, 0x00, 0xC1, 0x67, 0x67, 0x4D, 0xCF, 0x84, 0xF7,
+    0x57, 0xA6, 0xDA, 0x08, 0x52, 0xF5, 0xE5, 0xBA, 0xB8, 0x7B, 0x5B, 0x68, 0xEE, 0x2F, 0x66, 0x89, 0xB7, 0xB7, 0x9B,
+    0xE5, 0x9C, 0x23, 0xAA, 0xFE, 0xF7, 0x68, 0x11, 0x9E, 0x5D, 0x18, 0x12, 0x48, 0x56, 0x5C, 0x9F, 0x57, 0xB6, 0xF8,
+    0x33, 0xF0, 0xE2, 0x5B, 0xFB, 0xCF, 0xF4, 0x51, 0x0C, 0xC6, 0x64, 0x30, 0x49, 0x71, 0x7C, 0xE2, 0x16, 0x90, 0x2E,
+    0xF4, 0x72, 0xEA, 0xE0, 0x34, 0x81, 0x77, 0x93, 0x9C, 0x07, 0xC2, 0x93, 0xB9, 0x61, 0xC0, 0xD3, 0xF0, 0x17, 0xC1,
+    0xBF, 0x03, 0xCD, 0xE1, 0xAD, 0x42, 0x3F, 0x0A, 0xD8, 0xC7, 0x2D, 0xAC, 0x36, 0xCB, 0xF6, 0x79, 0x22, 0x69, 0x84,
+    0xC4, 0x93, 0x29, 0x2A, 0x89, 0xB9, 0x00, 0x50, 0x62, 0x7C, 0xFF, 0x00, 0x16, 0xD9, 0x65, 0x00, 0x16, 0x65, 0x07,
+    0xFA, 0x5B, 0x36, 0xE2, 0xAC, 0xBF, 0x2D, 0x55, 0x79, 0x29, 0xB5, 0x26, 0x9B, 0xA9, 0x18, 0xB5, 0x15, 0x36, 0x9B,
+    0x53, 0xD1, 0xCA, 0x10, 0x93, 0x69, 0xB6, 0x94, 0x27, 0x16, 0xAF, 0x19, 0x29, 0xB8, 0xBB, 0x3F, 0x9A, 0xE1, 0x1E,
+    0x2A, 0xCB, 0x9E, 0x79, 0x4A, 0x92, 0x84, 0xDA, 0xD6, 0xED, 0xA4, 0xED, 0x7A, 0x72, 0xB5, 0xAC, 0xF6, 0xEB, 0xAD,
+    0xD5, 0x97, 0x91, 0xC9, 0x4D, 0xA4, 0xE9, 0xD7, 0x56, 0x45, 0x66, 0xD3, 0x9D, 0x85, 0xB1, 0x86, 0x59, 0x7E, 0xD9,
+    0x7E, 0xA0, 0xE0, 0xA8, 0x02, 0x17, 0x02, 0x3C, 0x36, 0x59, 0x18, 0xE2, 0x42, 0x1D, 0x40, 0x56, 0x0A, 0x77, 0x30,
+    0xAE, 0xFA, 0x56, 0xD4, 0xA4, 0x8A, 0xD9, 0xAD, 0xD6, 0x38, 0x1D, 0x7F, 0x77, 0x77, 0x1C, 0xB2, 0x4C, 0x22, 0x8C,
+    0x2B, 0xF3, 0x14, 0x64, 0x45, 0x85, 0x52, 0x47, 0x92, 0x7E, 0xF2, 0x0F, 0x34, 0x1D, 0xBC, 0x56, 0xDE, 0x85, 0xF0,
+    0x4B, 0xE1, 0x0A, 0xE9, 0xB0, 0xDB, 0x2D, 0x8C, 0x4C, 0xCD, 0x74, 0xF1, 0x42, 0x96, 0x93, 0xCF, 0xF6, 0x54, 0x0C,
+    0xB3, 0x44, 0x03, 0xAA, 0x6C, 0x49, 0x10, 0x87, 0x00, 0x88, 0xC2, 0xEE, 0x66, 0x6F, 0x9B, 0xAB, 0x57, 0xA4, 0x68,
+    0xDF, 0x0A, 0x3E, 0x1B, 0xDA, 0xE9, 0xDF, 0xD9, 0x96, 0xFE, 0x03, 0xB2, 0x8E, 0xD9, 0x8A, 0xDD, 0xC1, 0x77, 0x14,
+    0x97, 0x50, 0x2E, 0xE3, 0x20, 0x62, 0xA0, 0x33, 0x0C, 0xC6, 0x58, 0x48, 0x36, 0x6D, 0xC1, 0x20, 0xA2, 0x2B, 0x00,
+    0xB5, 0xF1, 0x99, 0xCF, 0x19, 0x65, 0x79, 0xAD, 0x0C, 0x3C, 0x2B, 0x61, 0xF9, 0x28, 0xD6, 0x52, 0x97, 0x35, 0x95,
+    0xD4, 0x61, 0x28, 0x5B, 0x99, 0xB8, 0xA9, 0xA9, 0x47, 0xD9, 0x3A, 0x69, 0xA9, 0xC6, 0x51, 0x52, 0x6A, 0x0D, 0x4A,
+    0x74, 0xA9, 0xC3, 0xFA, 0x7F, 0xC3, 0xFE, 0x25, 0xC1, 0x4E, 0xAE, 0x26, 0x2E, 0x13, 0x71, 0x5C, 0x8D, 0xFB, 0xB1,
+    0xD6, 0xEA, 0x6F, 0xF9, 0xAF, 0xBE, 0xB7, 0x4B, 0x55, 0x1D, 0x75, 0x4C, 0xF3, 0xDF, 0x05, 0xD9, 0xF8, 0x7B, 0xC3,
+    0xBA, 0xB5, 0xF1, 0xBC, 0x8D, 0x63, 0xDF, 0x1C, 0x32, 0x88, 0x1A, 0xF3, 0x74, 0x73, 0x89, 0x15, 0xC4, 0x8A, 0x25,
+    0x66, 0xDC, 0xAA, 0x98, 0x60, 0x06, 0x7F, 0xBD, 0xF2, 0x81, 0xF3, 0x36, 0xFE, 0x9D, 0xAF, 0x78, 0x8F, 0x54, 0xD3,
+    0xAD, 0xA6, 0x9E, 0xC5, 0xE5, 0x9C, 0x96, 0xDC, 0xB7, 0xE8, 0x84, 0x47, 0xFB, 0xB4, 0x54, 0x42, 0x0F, 0x03, 0xF8,
+    0xD7, 0xE5, 0x39, 0x60, 0xF8, 0x04, 0x79, 0x7B, 0xE3, 0xF4, 0x9F, 0x85, 0x5F, 0x08, 0xBE, 0x0D, 0x2C, 0x57, 0xCE,
+    0x6C, 0xA5, 0x2B, 0xA8, 0x08, 0x20, 0x82, 0x04, 0xB9, 0xB8, 0x82, 0x43, 0x28, 0x72, 0x55, 0xD5, 0x83, 0xB9, 0x05,
+    0xC2, 0x44, 0x55, 0x77, 0x8C, 0xFC, 0xEC, 0xD8, 0xCB, 0xE7, 0xBE, 0x9B, 0xE0, 0x5F, 0xC3, 0x9D, 0x32, 0xD4, 0x45,
+    0x26, 0x8B, 0x2C, 0x93, 0xC0, 0xF3, 0x95, 0x49, 0xEE, 0x2E, 0x0C, 0x26, 0x26, 0x31, 0xC9, 0xF3, 0xED, 0x95, 0x96,
+    0x32, 0xEC, 0x10, 0xE1, 0xB8, 0x60, 0x3A, 0x90, 0x1B, 0x3F, 0x9E, 0x66, 0x58, 0xFC, 0x14, 0x31, 0x15, 0xFD, 0x9C,
+    0x79, 0x57, 0x3A, 0x92, 0x84, 0x1C, 0x3D, 0xC9, 0xCD, 0x27, 0x6D, 0x12, 0xE5, 0xE7, 0xA6, 0xD5, 0x4D, 0x64, 0x93,
+    0xD1, 0x45, 0xC6, 0xAD, 0xE7, 0x2F, 0xE9, 0xEE, 0x17, 0xE3, 0x0C, 0x0A, 0xE1, 0x9C, 0x37, 0x34, 0x67, 0x2B, 0x73,
+    0x2B, 0xB4, 0xBA, 0x49, 0xF4, 0x72, 0x57, 0x51, 0xDD, 0x24, 0x9B, 0x5A, 0x36, 0x9A, 0x49, 0x1E, 0x15, 0xA7, 0x7E,
+    0xCE, 0xF6, 0x89, 0x6A, 0x96, 0x43, 0x55, 0xB5, 0xB3, 0xB6, 0xB8, 0x96, 0x2B, 0x9B, 0x78, 0xA0, 0xB4, 0x9E, 0xE5,
+    0x61, 0x90, 0xE0, 0xC2, 0xEC, 0x61, 0x91, 0x47, 0xCC, 0xDB, 0xF1, 0x80, 0xC0, 0x98, 0xD4, 0xE5, 0xDC, 0x64, 0xEC,
+    0x7C, 0x29, 0xFD, 0x98, 0x6C, 0xAF, 0xEC, 0xF5, 0x76, 0xB7, 0xF1, 0x36, 0x9A, 0x5D, 0x6F, 0x96, 0xE1, 0x74, 0xB5,
+    0xD3, 0x44, 0x91, 0xA8, 0x45, 0x0C, 0xE2, 0x3D, 0xAC, 0x85, 0xF9, 0x3B, 0x5B, 0x19, 0x8A, 0x43, 0x1F, 0xCA, 0x50,
+    0x9D, 0x87, 0xD2, 0x0F, 0xC2, 0x1F, 0x89, 0x4F, 0x6D, 0x04, 0x0F, 0xE1, 0x61, 0xAA, 0xEE, 0xB4, 0x8E, 0x56, 0xFB,
+    0x06, 0xAF, 0x04, 0xF3, 0x40, 0x9B, 0x55, 0x4E, 0xCB, 0x66, 0x91, 0xCB, 0x18, 0xC2, 0x88, 0xB6, 0xB1, 0x65, 0x60,
+    0xA4, 0x6E, 0xDC, 0xA4, 0x9E, 0xAF, 0xE1, 0xBF, 0xC2, 0x2F, 0x89, 0xA9, 0xE1, 0xFB, 0x8D, 0x6E, 0xC2, 0x3B, 0x4B,
+    0x30, 0xD7, 0x60, 0xDA, 0x41, 0x2D, 0xCC, 0x6C, 0x2E, 0x49, 0xF3, 0x1E, 0x42, 0x19, 0x5D, 0x58, 0x3C, 0x8A, 0x81,
+    0x82, 0xB8, 0x0C, 0xC9, 0xF2, 0xE5, 0x8F, 0x03, 0x8F, 0x36, 0xE3, 0x8A, 0x98, 0xCC, 0x14, 0xAB, 0x62, 0x2B, 0xC2,
+    0x34, 0xA2, 0xA5, 0x78, 0x37, 0x42, 0x12, 0x70, 0x8C, 0x62, 0xD2, 0x6D, 0x72, 0x7B, 0xAF, 0x9B, 0xDD, 0xFD, 0xE5,
+    0x4E, 0x79, 0x49, 0x45, 0x73, 0xA9, 0x72, 0x2F, 0xF0, 0x73, 0x83, 0xF8, 0xCE, 0xB4, 0x33, 0xE8, 0x3F, 0xAE, 0x42,
+    0xF7, 0x76, 0xB3, 0x83, 0x57, 0xE5, 0x95, 0xBE, 0xCE, 0x8F, 0x7B, 0xDE, 0xD7, 0x4B, 0x6B, 0x9C, 0x1E, 0x8D, 0xF0,
+    0x56, 0x7B, 0xDD, 0x26, 0x34, 0x5F, 0x1F, 0xDB, 0x9D, 0x37, 0x53, 0xB8, 0x96, 0xED, 0xA0, 0x16, 0xB1, 0xC9, 0x2C,
+    0x8B, 0xF2, 0x26, 0x58, 0x89, 0x37, 0xEE, 0x04, 0xB2, 0x97, 0x54, 0x2D, 0x88, 0xC0, 0x60, 0x0B, 0x03, 0x5E, 0x9B,
+    0x67, 0xFB, 0x36, 0xE9, 0x31, 0x2D, 0x9C, 0x37, 0x9E, 0x32, 0x84, 0x5D, 0x2C, 0x4A, 0xD6, 0xAD, 0x73, 0x63, 0x28,
+    0x36, 0xAA, 0x53, 0xF7, 0x90, 0x29, 0x8E, 0x5C, 0x92, 0xBE, 0x41, 0xDC, 0xC0, 0xB3, 0x2B, 0x46, 0x32, 0x4B, 0x96,
+    0x35, 0xAD, 0x1F, 0xC2, 0xDF, 0x89, 0x17, 0xF6, 0xB6, 0xFA, 0xB5, 0xED, 0xB8, 0xB7, 0x8E, 0x78, 0x66, 0x96, 0x09,
+    0x6C, 0x6E, 0x23, 0x32, 0x28, 0x08, 0xE8, 0xF2, 0xBA, 0xF9, 0x86, 0x48, 0xC0, 0x68, 0xFE, 0x63, 0xC8, 0x23, 0x82,
+    0xCC, 0xA5, 0x4A, 0xFA, 0x66, 0x8F, 0xF0, 0x37, 0xE2, 0x6D, 0xE5, 0xC9, 0x3A, 0x87, 0x86, 0xB4, 0xFB, 0x28, 0xAE,
+    0x61, 0x0F, 0x0B, 0x59, 0xDF, 0xC0, 0xD1, 0xAC, 0xE0, 0x24, 0x41, 0x42, 0xC4, 0x49, 0x1B, 0x10, 0x21, 0x50, 0xC0,
+    0x09, 0x11, 0x8B, 0xEE, 0x6E, 0x71, 0xE2, 0xE2, 0x78, 0xBB, 0x33, 0xFA, 0xC5, 0x1A, 0xB4, 0xEA, 0xC6, 0x74, 0xD2,
+    0x8C, 0x24, 0xA5, 0x2A, 0x3C, 0xB5, 0x2E, 0xB9, 0x9B, 0x71, 0x97, 0x34, 0xE0, 0xAA, 0x54, 0x93, 0x71, 0x56, 0x49,
+    0xB9, 0xC6, 0x4E, 0x9A, 0x9B, 0xD3, 0xFA, 0x7F, 0x81, 0xB8, 0xD6, 0xAC, 0xDD, 0x6F, 0x65, 0x8D, 0x82, 0x77, 0x85,
+    0x95, 0xE1, 0x7D, 0x1C, 0xD2, 0x8B, 0x7A, 0x27, 0xA2, 0xF4, 0xED, 0xEE, 0x9E, 0x67, 0xE0, 0x8F, 0x81, 0x37, 0xBA,
+    0xEF, 0x87, 0x67, 0xBF, 0x8F, 0xC4, 0xD2, 0xDD, 0x4F, 0x05, 0xA8, 0x61, 0x7B, 0x1E, 0x9E, 0xE1, 0x8C, 0xEA, 0xF3,
+    0x18, 0x99, 0xA3, 0xDE, 0x76, 0x66, 0x36, 0x2A, 0x30, 0xFB, 0x9B, 0x0F, 0xC3, 0x1C, 0xA3, 0x76, 0x4B, 0xFB, 0x3B,
+    0xE8, 0xBA, 0x66, 0xBF, 0x0E, 0x93, 0xFD, 0xAB, 0x23, 0xD9, 0xA5, 0xCE, 0x62, 0xF3, 0x34, 0xEB, 0x7F, 0x29, 0x0A,
+    0xA7, 0x04, 0x48, 0xF2, 0x79, 0x82, 0x42, 0x1D, 0x46, 0x4B, 0xA9, 0x1B, 0xD1, 0xBE, 0x52, 0x54, 0xD7, 0xA8, 0xF8,
+    0x33, 0xE1, 0xAF, 0xC4, 0xA8, 0x24, 0xD6, 0x6D, 0xED, 0xBC, 0x0A, 0xD3, 0x5A, 0x5C, 0xC4, 0xDF, 0x64, 0x17, 0x97,
+    0x36, 0xF0, 0x65, 0x52, 0x39, 0xD4, 0x23, 0x22, 0x9D, 0xD8, 0x64, 0x83, 0x04, 0x85, 0x38, 0xEF, 0xB8, 0x49, 0x91,
+    0xBB, 0xFF, 0x00, 0x0A, 0xDF, 0xE3, 0x77, 0x84, 0xAC, 0xD3, 0x4A, 0xBC, 0xF0, 0x3A, 0x5A, 0x5B, 0x4F, 0x72, 0x5E,
+    0xD7, 0x53, 0x8E, 0xE2, 0x12, 0x6D, 0xC6, 0x40, 0x20, 0x47, 0xE6, 0x3E, 0x71, 0x26, 0x70, 0x24, 0xE4, 0xB4, 0x63,
+    0x2A, 0xC0, 0xE0, 0x7E, 0x71, 0x98, 0x71, 0x35, 0x5C, 0x4E, 0x69, 0x5A, 0xBD, 0x7C, 0x7A, 0x9C, 0xE3, 0xC9, 0xCF,
+    0x38, 0x46, 0x8D, 0xA4, 0xDC, 0x63, 0x38, 0x4A, 0xE9, 0xED, 0x5A, 0x4E, 0x4A, 0x6D, 0xF3, 0xCA, 0x2D, 0xB9, 0x4D,
+    0xD3, 0x77, 0x8C, 0x7F, 0xA8, 0xF8, 0x53, 0x8D, 0x31, 0x32, 0xC8, 0xA9, 0xDB, 0x15, 0x04, 0x9F, 0xB4, 0xD2, 0xF4,
+    0xD3, 0xF8, 0xA5, 0x77, 0xCD, 0xB3, 0x49, 0x6C, 0xB4, 0xEA, 0x97, 0x46, 0x78, 0x45, 0xC4, 0x16, 0x5A, 0xDD, 0xA5,
+    0xA6, 0x8D, 0xA7, 0xEA, 0x77, 0x4A, 0x54, 0x47, 0x3C, 0x31, 0x41, 0x20, 0x06, 0x68, 0x00, 0x9A, 0x4F, 0x2A, 0x40,
+    0x5D, 0x5F, 0x69, 0xF3, 0x15, 0xCB, 0x32, 0x96, 0xDC, 0xC0, 0x90, 0xA5, 0xF0, 0xBD, 0xAF, 0xC3, 0x96, 0x83, 0x51,
+    0xB8, 0xD6, 0xA7, 0x48, 0xD2, 0xE8, 0x2B, 0x2C, 0x2D, 0x6B, 0xF6, 0xA4, 0x55, 0x8E, 0x45, 0x5F, 0xBA, 0x54, 0x2A,
+    0x36, 0x77, 0x12, 0x72, 0xE5, 0x9C, 0x14, 0x3B, 0x63, 0x6C, 0x62, 0x8A, 0x2B, 0xDE, 0xCD, 0x70, 0x74, 0xA7, 0x92,
+    0xE2, 0x31, 0x35, 0x2D, 0x29, 0x54, 0xBB, 0x97, 0xBB, 0x18, 0xF3, 0x38, 0x52, 0xA5, 0x38, 0xDF, 0x92, 0x31, 0x7E,
+    0xEB, 0x9B, 0x6A, 0xCD, 0x6B, 0xEF, 0x7C, 0x6E, 0x52, 0x7F, 0xE1, 0xF7, 0x0E, 0x54, 0x96, 0x1B, 0x3D, 0x52, 0x86,
+    0xF0, 0x73, 0x4B, 0xEE, 0x92, 0xD6, 0xD6, 0xBF, 0xC2, 0x8D, 0x9F, 0x0B, 0xDE, 0xEB, 0xF3, 0x69, 0x6B, 0x06, 0x9B,
+    0xA9, 0x5B, 0xE9, 0xF6, 0x6F, 0x76, 0x1E, 0x45, 0x8E, 0xE1, 0x54, 0xC8, 0xCD, 0xF3, 0x28, 0x8B, 0x1C, 0x9E, 0x25,
+    0x55, 0xDA, 0xA5, 0x58, 0x80, 0xCA, 0x46, 0x42, 0xA8, 0xF4, 0x1B, 0xEB, 0xBB, 0xBB, 0x8B, 0x69, 0xAF, 0xA5, 0x8E,
+    0xD0, 0x49, 0x25, 0x9C, 0x37, 0x73, 0xE9, 0xD7, 0xF2, 0x14, 0x8E, 0x55, 0x91, 0x64, 0x90, 0x46, 0xA8, 0xF9, 0x50,
+    0x57, 0x73, 0x2E, 0xE0, 0x55, 0xF6, 0x87, 0x45, 0x20, 0x2E, 0xC7, 0x28, 0xAF, 0xCD, 0x78, 0xA6, 0xA5, 0x5C, 0x26,
+    0x33, 0x01, 0x35, 0x2E, 0x67, 0x52, 0x35, 0xA0, 0xEE, 0x93, 0x56, 0x70, 0x4F, 0x48, 0xDB, 0x95, 0x6B, 0x76, 0xF4,
+    0xB4, 0xA5, 0x27, 0x29, 0x29, 0x35, 0x16, 0xBF, 0xA8, 0x7C, 0x3E, 0x92, 0xF6, 0x98, 0xA8, 0x5B, 0x4B, 0xC5, 0xDB,
+    0x5E, 0x8E, 0x4F, 0x7D, 0xFA, 0xDB, 0x57, 0xB2, 0x56, 0xD6, 0xED, 0xF7, 0x3E, 0x10, 0xB2, 0x82, 0xF6, 0xC2, 0xF2,
+    0xF3, 0x4E, 0xD4, 0xAF, 0xEE, 0x5A, 0xCA, 0xCE, 0xD2, 0xF1, 0xA7, 0xB8, 0x9D, 0xD4, 0x42, 0x8C, 0xF2, 0x3C, 0x8E,
+    0x42, 0x02, 0x24, 0xFD, 0xDA, 0x96, 0x60, 0xAD, 0xB0, 0xC9, 0x0E, 0x00, 0xC8, 0xC8, 0xEA, 0xEE, 0x12, 0x7B, 0x09,
+    0x6C, 0x6E, 0xCE, 0xA2, 0x0B, 0xAA, 0x32, 0xD9, 0xB9, 0x49, 0x66, 0xDF, 0x74, 0xCC, 0x31, 0x1B, 0xE4, 0xE6, 0x63,
+    0xF2, 0x91, 0x95, 0x42, 0x15, 0x8B, 0x7D, 0xE0, 0xAC, 0xB4, 0x51, 0x5F, 0x33, 0x3A, 0xD8, 0x8C, 0x46, 0x7A, 0x9C,
+    0xA6, 0xD7, 0x2C, 0x13, 0x49, 0x25, 0x6E, 0x6A, 0x73, 0xE4, 0x84, 0x9E, 0x9A, 0xC9, 0x29, 0x24, 0x9E, 0xE9, 0x42,
+    0x11, 0x8D, 0xA2, 0x9C, 0x5F, 0xF5, 0x37, 0x0D, 0x36, 0xF8, 0x7E, 0x9A, 0xEC, 0xE5, 0xE5, 0x7E, 0x67, 0x77, 0x7B,
+    0x7A, 0xBF, 0x5E, 0xB7, 0x3F, 0xFF, 0xD9,
+};
+
 static void set_loop_time(uint32_t now) { LoopBlockingGuard clock(nullptr, LOG_STR("test"), now); }

 class OnlineImageDownloadEnd : public ::testing::Test {
 protected:
-  std::unique_ptr<OnlineImage> make_image_(runtime_image::ImageFormat format) {
+  std::unique_ptr<OnlineImage> make_image_(runtime_image::ImageFormat format, uint32_t buffer_size = 256) {
    auto img = std::make_unique<OnlineImage>("http://example.com/image", 0, 0, format, image::IMAGE_TYPE_RGB,
-                                             image::TRANSPARENCY_OPAQUE, nullptr, 256);
+                                             image::TRANSPARENCY_OPAQUE, nullptr, buffer_size);
    img->set_parent(&this->http_);
    return img;
  }
@@ -286,4 +454,260 @@ TEST_F(OnlineImageDownloadEnd, JpegBufferAllocationFailureReportsError) {
  EXPECT_EQ(this->finished_, 0);
 }

+// 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);
+  std::vector<uint8_t> data(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40));
+  EXPECT_TRUE(ref.begin_decode(data.size()));
+  EXPECT_EQ(ref.feed_data(data.data(), data.size()), static_cast<int>(data.size()));
+  EXPECT_TRUE(ref.end_decode());
+  return std::vector<uint8_t>(ref.get_data_start(), ref.get_data_start() + ref.get_width_stride() * ref.get_height());
+}
+
+static std::vector<uint8_t> image_pixels(OnlineImage &image) {
+  return std::vector<uint8_t>(image.get_data_start(),
+                              image.get_data_start() + image.get_width_stride() * image.get_height());
+}
+
+// A JPEG of known size is decoded as it arrives, so a buffer smaller than the file only has to hold the headers
+TEST_F(OnlineImageDownloadEnd, JpegDecodesThroughASmallBuffer) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  // Bytes after the image are never needed. Waiting for the whole file before decoding would read them all.
+  std::vector<uint8_t> body(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40));
+  body.resize(body.size() + 8192, 0);
+  auto container = std::make_shared<FakeContainer>(body, body.size(), false);
+  container->add_response_header("etag", "\"abc\"");
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_LT(container->get_bytes_read(), body.size()) << "the image was not decoded as it arrived";
+  EXPECT_EQ(this->errors_, 0);
+  ASSERT_EQ(image->get_width(), 48);
+  ASSERT_EQ(image->get_height(), 40);
+  EXPECT_EQ(image_pixels(*image), reference_jpeg_pixels());
+
+  // A complete image is cached
+  this->http_.next = std::make_shared<FakeContainer>(std::vector<uint8_t>{}, 0, false);
+  image->update();
+  EXPECT_TRUE(this->http_.sent_header("if-none-match"));
+}
+
+// A slow link: the decoder waits part way through the image for the rest to arrive
+TEST_F(OnlineImageDownloadEnd, JpegWaitsForASlowDownload) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 1024, false);
+  this->start_(*image, container);
+
+  int passes = 0;
+  for (; passes < 1000 && this->finished_ + this->errors_ == 0; passes++) {
+    image->loop();
+    if (passes == 5) {
+      EXPECT_EQ(this->finished_, 0) << "the image cannot be finished before the rest of it arrives";
+    }
+    container->deliver(40);
+  }
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(this->errors_, 0);
+  EXPECT_GT(passes, 10);
+  EXPECT_EQ(image_pixels(*image), reference_jpeg_pixels());
+}
+
+// A download that stops part way through times out rather than waiting for ever
+TEST_F(OnlineImageDownloadEnd, JpegDownloadThatStopsTimesOut) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 1500, false);
+  set_loop_time(1000);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 10; i++)
+    image->loop();
+  EXPECT_EQ(this->errors_, 0) << "still within the timeout";
+
+  set_loop_time(1000 + this->http_.get_timeout());
+  image->loop();
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+// Headers that do not fit the download buffer cannot be read as the image arrives, so the whole image is
+// downloaded first, keeping the bytes already read
+TEST_F(OnlineImageDownloadEnd, JpegHeadersLargerThanTheBufferDownloadTheWholeImage) {
+  auto image = this->make_image_(runtime_image::JPEG, 256);
+  auto container = std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)),
+                                                   sizeof(JPEG_48X40), false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++) {
+    image->loop();
+    container->deliver(256);
+  }
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(this->errors_, 0);
+  EXPECT_EQ(container->get_bytes_read(), sizeof(JPEG_48X40));
+  EXPECT_EQ(image_pixels(*image), reference_jpeg_pixels());
+}
+
+// The pass that opens the image does not decode any of it
+TEST_F(OnlineImageDownloadEnd, JpegOpensInAPassOfItsOwn) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container = std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)),
+                                                   sizeof(JPEG_48X40), false);
+  this->start_(*image, container);
+
+  image->loop();
+  EXPECT_EQ(this->finished_ + this->errors_, 0);
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+  EXPECT_EQ(this->finished_, 1);
+}
+
+// A progressive JPEG is refused while it downloads, without blaming the buffer size
+TEST_F(OnlineImageDownloadEnd, JpegProgressiveReportsError) {
+  auto image = this->make_image_(runtime_image::JPEG, 256);
+  std::vector<uint8_t> body(JPEG_PROGRESSIVE, JPEG_PROGRESSIVE + sizeof(JPEG_PROGRESSIVE));
+  auto container = std::make_shared<FakeContainer>(body, 256, false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 10 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+// on_download_started fires once the server has accepted the request, before the first progress report, and not
+// for a response that has no image to download
+TEST_F(OnlineImageDownloadEnd, StartedFiresOnlyWhenTheDownloadBegins) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  std::vector<std::string> events;
+  image->add_on_download_started_callback([&events]() { events.emplace_back("started"); });
+  image->add_on_progress_callback([&events](float, size_t) { events.emplace_back("progress"); });
+  this->start_(*image,
+               std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)),
+                                               sizeof(JPEG_48X40), false));
+  ASSERT_GE(events.size(), 2u);
+  EXPECT_EQ(events[0], "started");
+  EXPECT_EQ(events[1], "progress");
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+  EXPECT_EQ(std::count(events.begin(), events.end(), std::string("started")), 1);
+
+  for (int status : {304, 404}) {
+    events.clear();
+    auto container = std::make_shared<FakeContainer>(std::vector<uint8_t>{}, 0, false);
+    container->status_code = status;
+    this->http_.next = container;
+    image->update();
+    EXPECT_TRUE(events.empty()) << "HTTP " << status;
+  }
+}
+
+// Progress starts at 0, is reported at most every 100 ms, and always reaches 100%
+TEST_F(OnlineImageDownloadEnd, ProgressIsReportedAsTheImageDownloads) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  std::vector<float> reports;
+  image->add_on_progress_callback([&reports](float progress, size_t) { reports.push_back(progress); });
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 100, false);
+  uint32_t now = 1000;
+  set_loop_time(now);
+  this->start_(*image, container);
+  ASSERT_EQ(reports.size(), 1u);
+  EXPECT_EQ(reports[0], 0.0f);
+
+  int passes = 0;
+  for (; passes < 1000 && this->finished_ + this->errors_ == 0; passes++) {
+    now += 50;
+    set_loop_time(now);
+    container->deliver(100);
+    image->loop();
+  }
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(reports.back(), 100.0f);
+  EXPECT_TRUE(std::is_sorted(reports.begin(), reports.end()));
+  // A report every 100 ms of a 50 ms loop, plus the start and the end
+  EXPECT_LE(reports.size(), static_cast<size_t>(passes / 2 + 2));
+  EXPECT_GT(reports.size(), 3u);
+}
+
+// Without a Content-Length the percentage is unknown, but the bytes read are still reported
+TEST_F(OnlineImageDownloadEnd, ProgressOfAChunkedDownloadHasNoPercentage) {
+  auto image = this->make_image_(runtime_image::PNG);
+  std::vector<std::pair<float, size_t>> reports;
+  image->add_on_progress_callback(
+      [&reports](float progress, size_t bytes_read) { reports.emplace_back(progress, bytes_read); });
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(PNG_1X1.begin(), PNG_1X1.end()), PNG_1X1.size(), true);
+  set_loop_time(1000);
+  this->start_(*image, container);
+  set_loop_time(2000);
+  for (int i = 0; i < 10 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+
+  ASSERT_GE(reports.size(), 2u);
+  EXPECT_TRUE(std::isnan(reports.back().first));
+  EXPECT_EQ(reports.back().second, PNG_1X1.size());
+}
+
+// Scan data that cannot be decoded fails the download part way through
+TEST_F(OnlineImageDownloadEnd, JpegDecodeErrorFailsTheDownload) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  std::vector<uint8_t> body(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40));
+  std::fill(body.begin() + 700, body.end() - 2, 0xFE);
+  auto container = std::make_shared<FakeContainer>(body, 1024, false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++) {
+    image->loop();
+    container->deliver(256);
+  }
+
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+// A read that fails part way through the download ends it with an error
+TEST_F(OnlineImageDownloadEnd, JpegReadErrorFailsTheDownload) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 1024, false);
+  this->start_(*image, container);
+  for (int i = 0; i < 5; i++)
+    image->loop();
+  ASSERT_EQ(this->errors_, 0);
+
+  container->fail_reads();
+  image->loop();
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+TEST(DownloadBufferGrow, KeepsTheUnreadData) {
+  DownloadBuffer buffer(16);
+  std::memcpy(buffer.append(), "abcdef", 6);
+  buffer.write(6);
+  buffer.read(2);
+
+  ASSERT_TRUE(buffer.grow(64));
+  EXPECT_EQ(buffer.size(), 64u);
+  ASSERT_EQ(buffer.unread(), 4u);
+  EXPECT_EQ(std::memcmp(buffer.data(), "cdef", 4), 0);
+
+  // A failed allocation leaves the buffer as it was
+  EXPECT_FALSE(buffer.grow(SIZE_MAX / 2));
+  EXPECT_EQ(buffer.size(), 64u);
+  EXPECT_EQ(std::memcmp(buffer.data(), "cdef", 4), 0);
+  // Growing to a smaller size changes nothing
+  EXPECT_TRUE(buffer.grow(8));
+  EXPECT_EQ(buffer.size(), 64u);
+}
+
 }  // namespace esphome::online_image::testing
@@ -4,9 +4,11 @@
 #include <algorithm>
 #include <array>
 #include <cstring>
+#include <utility>
 #include <vector>

 #include "esphome/components/runtime_image/image_decoder.h"
+#include "esphome/components/runtime_image/jpeg_decoder.h"
 #include "esphome/components/runtime_image/runtime_image.h"

 namespace esphome::runtime_image::testing {
@@ -362,6 +364,23 @@ static std::vector<uint8_t> pixel_bytes(TestableRuntimeImage &img) {
  return std::vector<uint8_t>(start, start + img.get_width_stride() * img.get_height());
 }

+// Shrinking a PNG keeps the first source pixel of each span, as the JPEG path does: the even rows and columns
+TEST(RuntimeImageDecoder, ShrunkPngKeepsTheFirstPixelOfEachSpan) {
+  TestableRuntimeImage img(PNG, image::IMAGE_TYPE_RGB, false, 2, 2);
+  ASSERT_TRUE(decode_all(img, PNG_RGB, sizeof(PNG_RGB), PNG));
+  ASSERT_EQ(img.get_width(), 2);
+  ASSERT_EQ(img.get_height(), 2);
+  for (int row = 0; row < 2; row++) {
+    for (int col = 0; col < 2; col++) {
+      const Color pixel = img.get_pixel(col, row);
+      const uint8_t *expected = PNG_RGB_EXPECTED[row * 2][col * 2];
+      EXPECT_EQ(pixel.r, expected[0]) << col << "," << row;
+      EXPECT_EQ(pixel.g, expected[1]) << col << "," << row;
+      EXPECT_EQ(pixel.b, expected[2]) << col << "," << row;
+    }
+  }
+}
+
 TEST(RuntimeImageDecoder, JpegDecoderStaysWarmAcrossDecodes) {
  TestableRuntimeImage img(JPEG);

@@ -377,6 +396,12 @@ TEST(RuntimeImageDecoder, JpegDecoderStaysWarmAcrossDecodes) {
  EXPECT_EQ(pixel_bytes(img), first_pixels) << "reused decoder must reproduce identical pixels";
 }

+// The RGB565 word at (x, y) of a decoded image, in its own byte order
+static uint16_t rgb565_word(const TestableRuntimeImage &img, int x, int y) {
+  const uint8_t *p = img.get_data_start() + (y * img.get_width() + x) * 2;
+  return p[0] | (p[1] << 8);
+}
+
 // JPEGDEC's colour conversion differs by one step between its SIMD and scalar builds, so each
 // channel is checked within one step; the byte order is still exact
 static void expect_rgb565_near(uint16_t actual, uint16_t expected, const char *order, size_t pixel) {
@@ -386,16 +411,12 @@ static void expect_rgb565_near(uint16_t actual, uint16_t expected, const char *o
 }

 TEST(RuntimeImageDecoder, JpegDecodesDirectlyToScaledRgb565WithBothByteOrders) {
-  // Halving the 8x8 gradient keeps its even rows and columns. The words are JPEGDEC's output for those
-  // pixels, red in the top five bits: a decode of the fixture with PIL gives (51, 7, 30) for source
-  // pixel (2, 0), which is word 0x3803 here.
-  static const uint16_t EXPECTED[4 * 4] = {
-      0x0000, 0x3803, 0x8008, 0xB80B, 0x0203, 0x3A07, 0x81EC, 0xBA0F,
-      0x03E7, 0x3C0B, 0x83F0, 0xBC13, 0x05EC, 0x3E0F, 0x85F4, 0xBE17,
-  };
+  // Halving the 8x8 gradient makes JPEGDEC decode it at half size, which averages each 2x2 block of pixels
+  TestableRuntimeImage full(JPEG, image::IMAGE_TYPE_RGB565, false, 8, 8);
  TestableRuntimeImage rgb565_little_endian(JPEG, image::IMAGE_TYPE_RGB565, false, 4, 4);
  TestableRuntimeImage rgb565_big_endian(JPEG, image::IMAGE_TYPE_RGB565, true, 4, 4);

+  ASSERT_TRUE(decode_all(full, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
  ASSERT_TRUE(decode_all(rgb565_little_endian, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
  ASSERT_TRUE(decode_all(rgb565_big_endian, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
  ASSERT_EQ(rgb565_little_endian.get_width(), 4);
@@ -405,9 +426,24 @@ TEST(RuntimeImageDecoder, JpegDecodesDirectlyToScaledRgb565WithBothByteOrders) {

  const uint8_t *little = rgb565_little_endian.get_data_start();
  const uint8_t *big = rgb565_big_endian.get_data_start();
-  for (size_t i = 0; i < 4 * 4; i++) {
-    expect_rgb565_near(little[i * 2] | (little[i * 2 + 1] << 8), EXPECTED[i], "little-endian", i);
-    expect_rgb565_near((big[i * 2] << 8) | big[i * 2 + 1], EXPECTED[i], "big-endian", i);
+  for (int row = 0; row < 4; row++) {
+    for (int col = 0; col < 4; col++) {
+      int red = 0;
+      int green = 0;
+      int blue = 0;
+      for (int dy = 0; dy < 2; dy++) {
+        for (int dx = 0; dx < 2; dx++) {
+          const uint16_t word = rgb565_word(full, col * 2 + dx, row * 2 + dy);
+          red += word >> 11;
+          green += (word >> 5) & 0x3F;
+          blue += word & 0x1F;
+        }
+      }
+      const uint16_t expected = ((red + 2) / 4) << 11 | ((green + 2) / 4) << 5 | (blue + 2) / 4;
+      const size_t i = row * 4 + col;
+      expect_rgb565_near(little[i * 2] | (little[i * 2 + 1] << 8), expected, "little-endian", i);
+      expect_rgb565_near((big[i * 2] << 8) | big[i * 2 + 1], expected, "big-endian", i);
+    }
  }
 }

@@ -415,19 +451,25 @@ TEST(RuntimeImageDecoder, JpegDecodesDirectlyToScaledRgb565WithBothByteOrders) {
 // prepare_rgb565_scaling_ 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; }

-// The RGB565 word at (x, y) of a decoded image, in its own byte order
-static uint16_t rgb565_word(const TestableRuntimeImage &img, int x, int y) {
-  const uint8_t *p = img.get_data_start() + (y * img.get_width() + x) * 2;
-  return p[0] | (p[1] << 8);
-}
-
 // Every scaled direct decode must equal the unscaled one sampled through the boundary table,
 // for shrinking, growing and a ratio that is not a whole number
+// JPEGDEC decodes at the smallest of full, 1/2, 1/4 and 1/8 size that still covers the buffer
+TEST(RuntimeImageDecoder, JpegDecodesAtTheSmallestSizeThatCoversTheBuffer) {
+  for (auto [size, scale] :
+       {std::pair{8, 1}, std::pair{5, 1}, std::pair{4, 2}, std::pair{3, 2}, std::pair{2, 4}, std::pair{1, 8}}) {
+    TestableRuntimeImage img(JPEG, image::IMAGE_TYPE_RGB565, false, size, size);
+    ASSERT_TRUE(decode_all(img, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
+    EXPECT_EQ(img.get_width(), size);
+    EXPECT_EQ(static_cast<JpegDecoder *>(img.decoder())->get_scale(), scale) << size << "x" << size;
+  }
+}
+
 TEST(RuntimeImageDecoder, JpegDirectRgb565ScalesBySourcePixelSpans) {
  TestableRuntimeImage full(JPEG, image::IMAGE_TYPE_RGB565, false, 8, 8);
  ASSERT_TRUE(decode_all(full, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));

-  for (int size : {4, 6, 16}) {
+  // Sizes JPEGDEC cannot reach by scaling, so the full size decode is spread over the buffer
+  for (int size : {5, 6, 16}) {
    TestableRuntimeImage scaled(JPEG, image::IMAGE_TYPE_RGB565, false, size, size);
    ASSERT_TRUE(decode_all(scaled, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
    ASSERT_EQ(scaled.get_width(), size);
@@ -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
@@ -0,0 +1,83 @@
+#include <gtest/gtest.h>
+
+#include <cstdlib>
+#include <vector>
+
+#include "esphome/components/runtime_image/runtime_image.h"
+
+#ifdef USE_RUNTIME_IMAGE_JPEG
+
+namespace esphome::runtime_image::testing {
+
+// 16x8 grayscale JPEG (quality 95) of a smooth gradient, from 60 at the top left to 185 at the bottom right
+static const uint8_t JPEG_GRAY[] = {
+    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+    0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,
+    0x02, 0x02, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x05, 0x04, 0x04, 0x03, 0x04, 0x06, 0x05, 0x06, 0x06, 0x06, 0x05,
+    0x06, 0x06, 0x06, 0x07, 0x09, 0x08, 0x06, 0x07, 0x09, 0x07, 0x06, 0x06, 0x08, 0x0B, 0x08, 0x09, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x06, 0x08, 0x0B, 0x0C, 0x0B, 0x0A, 0x0C, 0x09, 0x0A, 0x0A, 0x0A, 0xFF, 0xC0, 0x00, 0x0B, 0x08, 0x00,
+    0x08, 0x00, 0x10, 0x01, 0x01, 0x11, 0x00, 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+    0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04,
+    0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
+    0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
+    0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36,
+    0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+    0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84,
+    0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
+    0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6,
+    0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
+    0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xDA, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x00, 0x3F, 0x00, 0xF0, 0x9F, 0x82, 0x5F, 0x09, 0x3F, 0xD4, 0xFF, 0x00, 0xA2, 0xFA, 0x76, 0xAF, 0xB0,
+    0x3E, 0x09, 0x7C, 0x24, 0xFF, 0x00, 0x53, 0xFE, 0x8B, 0xE9, 0xDA, 0xBF, 0xFF, 0xD9,
+};
+
+// The pixels Pillow decodes from it
+static const uint8_t JPEG_GRAY_PIXELS[8 * 16] = {
+    60,  66,  72,  78,  84,  90,  96,  102, 108, 114, 120, 126, 132, 138, 144, 150, 65,  71,  77,  83,  89,  95,
+    101, 107, 113, 119, 125, 131, 137, 143, 149, 155, 70,  76,  82,  88,  94,  100, 106, 112, 118, 124, 130, 136,
+    142, 148, 154, 160, 75,  81,  87,  93,  99,  105, 111, 117, 123, 129, 135, 141, 147, 153, 159, 165, 80,  86,
+    92,  98,  104, 110, 116, 122, 128, 134, 140, 146, 152, 158, 164, 170, 85,  91,  97,  103, 109, 115, 121, 127,
+    133, 139, 145, 151, 157, 163, 169, 175, 90,  96,  102, 108, 114, 120, 126, 132, 138, 144, 150, 156, 162, 168,
+    174, 180, 95,  101, 107, 113, 119, 125, 131, 137, 143, 149, 155, 161, 167, 173, 179, 185,
+};
+
+// JPEGDEC's faster inverse DCT is up to 4 steps from Pillow's on this image; the garbled output was off by hundreds
+static constexpr int TOLERANCE = 5;
+
+static bool decode(RuntimeImage &img) {
+  std::vector<uint8_t> data(JPEG_GRAY, JPEG_GRAY + sizeof(JPEG_GRAY));
+  if (!img.begin_decode(data.size()))
+    return false;
+  if (img.feed_data(data.data(), data.size()) != static_cast<int>(data.size()))
+    return false;
+  return img.end_decode();
+}
+
+// A grayscale JPEG decoded for a colour image goes through JPEGDEC's RGB8888 output, which used to be garbled
+TEST(JpegGrayscale, DecodesToRgb) {
+  RuntimeImage img(JPEG, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_ALPHA_CHANNEL);
+  ASSERT_TRUE(decode(img));
+  ASSERT_EQ(img.get_width(), 16);
+  ASSERT_EQ(img.get_height(), 8);
+  const uint8_t *data = img.get_data_start();
+  for (int i = 0; i < 16 * 8; i++) {
+    const uint8_t *pixel = data + i * 4;  // blue, green, red, alpha
+    EXPECT_NEAR(pixel[0], JPEG_GRAY_PIXELS[i], TOLERANCE) << "blue of pixel " << i;
+    EXPECT_NEAR(pixel[1], JPEG_GRAY_PIXELS[i], TOLERANCE) << "green of pixel " << i;
+    EXPECT_NEAR(pixel[2], JPEG_GRAY_PIXELS[i], TOLERANCE) << "red of pixel " << i;
+    EXPECT_EQ(pixel[3], 255) << "alpha of pixel " << i;
+  }
+}
+
+TEST(JpegGrayscale, DecodesToGrayscale) {
+  RuntimeImage img(JPEG, image::IMAGE_TYPE_GRAYSCALE, image::TRANSPARENCY_OPAQUE);
+  ASSERT_TRUE(decode(img));
+  const uint8_t *data = img.get_data_start();
+  for (int i = 0; i < 16 * 8; i++)
+    EXPECT_NEAR(data[i], JPEG_GRAY_PIXELS[i], TOLERANCE) << "pixel " << i;
+}
+
+}  // namespace esphome::runtime_image::testing
+
+#endif  // USE_RUNTIME_IMAGE_JPEG
@@ -0,0 +1,434 @@
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cstring>
+#include <vector>
+
+#include "esphome/components/runtime_image/image_decoder.h"
+#include "esphome/components/runtime_image/runtime_image.h"
+
+#ifdef USE_RUNTIME_IMAGE_JPEG
+
+namespace esphome::runtime_image::testing {
+
+// 48x40 4:2:0 JPEG of a noisy gradient (quality 95): three rows of 16 pixel MCUs, so a stepped decode takes
+// three steps. At 2344 bytes it is larger than JPEGDEC's 2048 byte read buffer, so the source is read again
+// part way through the image.
+static const uint8_t JPEG_ROWS[] = {
+    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+    0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,
+    0x02, 0x02, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x05, 0x04, 0x04, 0x03, 0x04, 0x06, 0x05, 0x06, 0x06, 0x06, 0x05,
+    0x06, 0x06, 0x06, 0x07, 0x09, 0x08, 0x06, 0x07, 0x09, 0x07, 0x06, 0x06, 0x08, 0x0B, 0x08, 0x09, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x06, 0x08, 0x0B, 0x0C, 0x0B, 0x0A, 0x0C, 0x09, 0x0A, 0x0A, 0x0A, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x02,
+    0x02, 0x02, 0x02, 0x02, 0x02, 0x05, 0x03, 0x03, 0x05, 0x0A, 0x07, 0x06, 0x07, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x28, 0x00, 0x30, 0x03, 0x01, 0x22, 0x00,
+    0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+    0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00,
+    0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62,
+    0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37,
+    0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A,
+    0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85,
+    0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
+    0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
+    0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
+    0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00,
+    0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
+    0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04,
+    0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,
+    0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09,
+    0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A,
+    0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
+    0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75,
+    0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
+    0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
+    0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
+    0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
+    0xFA, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3F, 0x00, 0xFC, 0xAA, 0xB8, 0xB7,
+    0xD3, 0xB5, 0xD8, 0x1E, 0xD6, 0xD1, 0xA5, 0x5B, 0x4B, 0x46, 0x10, 0xC1, 0x06, 0xA1, 0x29, 0x69, 0x25, 0xB7, 0xC2,
+    0xC6, 0x0C, 0x71, 0x26, 0x5E, 0x50, 0x15, 0x5D, 0xB6, 0x9C, 0x9E, 0x00, 0xC1, 0x67, 0x67, 0x4D, 0xCF, 0x84, 0xF7,
+    0x57, 0xA6, 0xDA, 0x08, 0x52, 0xF5, 0xE5, 0xBA, 0xB8, 0x7B, 0x5B, 0x68, 0xEE, 0x2F, 0x66, 0x89, 0xB7, 0xB7, 0x9B,
+    0xE5, 0x9C, 0x23, 0xAA, 0xFE, 0xF7, 0x68, 0x11, 0x9E, 0x5D, 0x18, 0x12, 0x48, 0x56, 0x5C, 0x9F, 0x57, 0xB6, 0xF8,
+    0x33, 0xF0, 0xE2, 0x5B, 0xFB, 0xCF, 0xF4, 0x51, 0x0C, 0xC6, 0x64, 0x30, 0x49, 0x71, 0x7C, 0xE2, 0x16, 0x90, 0x2E,
+    0xF4, 0x72, 0xEA, 0xE0, 0x34, 0x81, 0x77, 0x93, 0x9C, 0x07, 0xC2, 0x93, 0xB9, 0x61, 0xC0, 0xD3, 0xF0, 0x17, 0xC1,
+    0xBF, 0x03, 0xCD, 0xE1, 0xAD, 0x42, 0x3F, 0x0A, 0xD8, 0xC7, 0x2D, 0xAC, 0x36, 0xCB, 0xF6, 0x79, 0x22, 0x69, 0x84,
+    0xC4, 0x93, 0x29, 0x2A, 0x89, 0xB9, 0x00, 0x50, 0x62, 0x7C, 0xFF, 0x00, 0x16, 0xD9, 0x65, 0x00, 0x16, 0x65, 0x07,
+    0xFA, 0x5B, 0x36, 0xE2, 0xAC, 0xBF, 0x2D, 0x55, 0x79, 0x29, 0xB5, 0x26, 0x9B, 0xA9, 0x18, 0xB5, 0x15, 0x36, 0x9B,
+    0x53, 0xD1, 0xCA, 0x10, 0x93, 0x69, 0xB6, 0x94, 0x27, 0x16, 0xAF, 0x19, 0x29, 0xB8, 0xBB, 0x3F, 0x9A, 0xE1, 0x1E,
+    0x2A, 0xCB, 0x9E, 0x79, 0x4A, 0x92, 0x84, 0xDA, 0xD6, 0xED, 0xA4, 0xED, 0x7A, 0x72, 0xB5, 0xAC, 0xF6, 0xEB, 0xAD,
+    0xD5, 0x97, 0x91, 0xC9, 0x4D, 0xA4, 0xE9, 0xD7, 0x56, 0x45, 0x66, 0xD3, 0x9D, 0x85, 0xB1, 0x86, 0x59, 0x7E, 0xD9,
+    0x7E, 0xA0, 0xE0, 0xA8, 0x02, 0x17, 0x02, 0x3C, 0x36, 0x59, 0x18, 0xE2, 0x42, 0x1D, 0x40, 0x56, 0x0A, 0x77, 0x30,
+    0xAE, 0xFA, 0x56, 0xD4, 0xA4, 0x8A, 0xD9, 0xAD, 0xD6, 0x38, 0x1D, 0x7F, 0x77, 0x77, 0x1C, 0xB2, 0x4C, 0x22, 0x8C,
+    0x2B, 0xF3, 0x14, 0x64, 0x45, 0x85, 0x52, 0x47, 0x92, 0x7E, 0xF2, 0x0F, 0x34, 0x1D, 0xBC, 0x56, 0xDE, 0x85, 0xF0,
+    0x4B, 0xE1, 0x0A, 0xE9, 0xB0, 0xDB, 0x2D, 0x8C, 0x4C, 0xCD, 0x74, 0xF1, 0x42, 0x96, 0x93, 0xCF, 0xF6, 0x54, 0x0C,
+    0xB3, 0x44, 0x03, 0xAA, 0x6C, 0x49, 0x10, 0x87, 0x00, 0x88, 0xC2, 0xEE, 0x66, 0x6F, 0x9B, 0xAB, 0x57, 0xA4, 0x68,
+    0xDF, 0x0A, 0x3E, 0x1B, 0xDA, 0xE9, 0xDF, 0xD9, 0x96, 0xFE, 0x03, 0xB2, 0x8E, 0xD9, 0x8A, 0xDD, 0xC1, 0x77, 0x14,
+    0x97, 0x50, 0x2E, 0xE3, 0x20, 0x62, 0xA0, 0x33, 0x0C, 0xC6, 0x58, 0x48, 0x36, 0x6D, 0xC1, 0x20, 0xA2, 0x2B, 0x00,
+    0xB5, 0xF1, 0x99, 0xCF, 0x19, 0x65, 0x79, 0xAD, 0x0C, 0x3C, 0x2B, 0x61, 0xF9, 0x28, 0xD6, 0x52, 0x97, 0x35, 0x95,
+    0xD4, 0x61, 0x28, 0x5B, 0x99, 0xB8, 0xA9, 0xA9, 0x47, 0xD9, 0x3A, 0x69, 0xA9, 0xC6, 0x51, 0x52, 0x6A, 0x0D, 0x4A,
+    0x74, 0xA9, 0xC3, 0xFA, 0x7F, 0xC3, 0xFE, 0x25, 0xC1, 0x4E, 0xAE, 0x26, 0x2E, 0x13, 0x71, 0x5C, 0x8D, 0xFB, 0xB1,
+    0xD6, 0xEA, 0x6F, 0xF9, 0xAF, 0xBE, 0xB7, 0x4B, 0x55, 0x1D, 0x75, 0x4C, 0xF3, 0xDF, 0x05, 0xD9, 0xF8, 0x7B, 0xC3,
+    0xBA, 0xB5, 0xF1, 0xBC, 0x8D, 0x63, 0xDF, 0x1C, 0x32, 0x88, 0x1A, 0xF3, 0x74, 0x73, 0x89, 0x15, 0xC4, 0x8A, 0x25,
+    0x66, 0xDC, 0xAA, 0x98, 0x60, 0x06, 0x7F, 0xBD, 0xF2, 0x81, 0xF3, 0x36, 0xFE, 0x9D, 0xAF, 0x78, 0x8F, 0x54, 0xD3,
+    0xAD, 0xA6, 0x9E, 0xC5, 0xE5, 0x9C, 0x96, 0xDC, 0xB7, 0xE8, 0x84, 0x47, 0xFB, 0xB4, 0x54, 0x42, 0x0F, 0x03, 0xF8,
+    0xD7, 0xE5, 0x39, 0x60, 0xF8, 0x04, 0x79, 0x7B, 0xE3, 0xF4, 0x9F, 0x85, 0x5F, 0x08, 0xBE, 0x0D, 0x2C, 0x57, 0xCE,
+    0x6C, 0xA5, 0x2B, 0xA8, 0x08, 0x20, 0x82, 0x04, 0xB9, 0xB8, 0x82, 0x43, 0x28, 0x72, 0x55, 0xD5, 0x83, 0xB9, 0x05,
+    0xC2, 0x44, 0x55, 0x77, 0x8C, 0xFC, 0xEC, 0xD8, 0xCB, 0xE7, 0xBE, 0x9B, 0xE0, 0x5F, 0xC3, 0x9D, 0x32, 0xD4, 0x45,
+    0x26, 0x8B, 0x2C, 0x93, 0xC0, 0xF3, 0x95, 0x49, 0xEE, 0x2E, 0x0C, 0x26, 0x26, 0x31, 0xC9, 0xF3, 0xED, 0x95, 0x96,
+    0x32, 0xEC, 0x10, 0xE1, 0xB8, 0x60, 0x3A, 0x90, 0x1B, 0x3F, 0x9E, 0x66, 0x58, 0xFC, 0x14, 0x31, 0x15, 0xFD, 0x9C,
+    0x79, 0x57, 0x3A, 0x92, 0x84, 0x1C, 0x3D, 0xC9, 0xCD, 0x27, 0x6D, 0x12, 0xE5, 0xE7, 0xA6, 0xD5, 0x4D, 0x64, 0x93,
+    0xD1, 0x45, 0xC6, 0xAD, 0xE7, 0x2F, 0xE9, 0xEE, 0x17, 0xE3, 0x0C, 0x0A, 0xE1, 0x9C, 0x37, 0x34, 0x67, 0x2B, 0x73,
+    0x2B, 0xB4, 0xBA, 0x49, 0xF4, 0x72, 0x57, 0x51, 0xDD, 0x24, 0x9B, 0x5A, 0x36, 0x9A, 0x49, 0x1E, 0x15, 0xA7, 0x7E,
+    0xCE, 0xF6, 0x89, 0x6A, 0x96, 0x43, 0x55, 0xB5, 0xB3, 0xB6, 0xB8, 0x96, 0x2B, 0x9B, 0x78, 0xA0, 0xB4, 0x9E, 0xE5,
+    0x61, 0x90, 0xE0, 0xC2, 0xEC, 0x61, 0x91, 0x47, 0xCC, 0xDB, 0xF1, 0x80, 0xC0, 0x98, 0xD4, 0xE5, 0xDC, 0x64, 0xEC,
+    0x7C, 0x29, 0xFD, 0x98, 0x6C, 0xAF, 0xEC, 0xF5, 0x76, 0xB7, 0xF1, 0x36, 0x9A, 0x5D, 0x6F, 0x96, 0xE1, 0x74, 0xB5,
+    0xD3, 0x44, 0x91, 0xA8, 0x45, 0x0C, 0xE2, 0x3D, 0xAC, 0x85, 0xF9, 0x3B, 0x5B, 0x19, 0x8A, 0x43, 0x1F, 0xCA, 0x50,
+    0x9D, 0x87, 0xD2, 0x0F, 0xC2, 0x1F, 0x89, 0x4F, 0x6D, 0x04, 0x0F, 0xE1, 0x61, 0xAA, 0xEE, 0xB4, 0x8E, 0x56, 0xFB,
+    0x06, 0xAF, 0x04, 0xF3, 0x40, 0x9B, 0x55, 0x4E, 0xCB, 0x66, 0x91, 0xCB, 0x18, 0xC2, 0x88, 0xB6, 0xB1, 0x65, 0x60,
+    0xA4, 0x6E, 0xDC, 0xA4, 0x9E, 0xAF, 0xE1, 0xBF, 0xC2, 0x2F, 0x89, 0xA9, 0xE1, 0xFB, 0x8D, 0x6E, 0xC2, 0x3B, 0x4B,
+    0x30, 0xD7, 0x60, 0xDA, 0x41, 0x2D, 0xCC, 0x6C, 0x2E, 0x49, 0xF3, 0x1E, 0x42, 0x19, 0x5D, 0x58, 0x3C, 0x8A, 0x81,
+    0x82, 0xB8, 0x0C, 0xC9, 0xF2, 0xE5, 0x8F, 0x03, 0x8F, 0x36, 0xE3, 0x8A, 0x98, 0xCC, 0x14, 0xAB, 0x62, 0x2B, 0xC2,
+    0x34, 0xA2, 0xA5, 0x78, 0x37, 0x42, 0x12, 0x70, 0x8C, 0x62, 0xD2, 0x6D, 0x72, 0x7B, 0xAF, 0x9B, 0xDD, 0xFD, 0xE5,
+    0x4E, 0x79, 0x49, 0x45, 0x73, 0xA9, 0x72, 0x2F, 0xF0, 0x73, 0x83, 0xF8, 0xCE, 0xB4, 0x33, 0xE8, 0x3F, 0xAE, 0x42,
+    0xF7, 0x76, 0xB3, 0x83, 0x57, 0xE5, 0x95, 0xBE, 0xCE, 0x8F, 0x7B, 0xDE, 0xD7, 0x4B, 0x6B, 0x9C, 0x1E, 0x8D, 0xF0,
+    0x56, 0x7B, 0xDD, 0x26, 0x34, 0x5F, 0x1F, 0xDB, 0x9D, 0x37, 0x53, 0xB8, 0x96, 0xED, 0xA0, 0x16, 0xB1, 0xC9, 0x2C,
+    0x8B, 0xF2, 0x26, 0x58, 0x89, 0x37, 0xEE, 0x04, 0xB2, 0x97, 0x54, 0x2D, 0x88, 0xC0, 0x60, 0x0B, 0x03, 0x5E, 0x9B,
+    0x67, 0xFB, 0x36, 0xE9, 0x31, 0x2D, 0x9C, 0x37, 0x9E, 0x32, 0x84, 0x5D, 0x2C, 0x4A, 0xD6, 0xAD, 0x73, 0x63, 0x28,
+    0x36, 0xAA, 0x53, 0xF7, 0x90, 0x29, 0x8E, 0x5C, 0x92, 0xBE, 0x41, 0xDC, 0xC0, 0xB3, 0x2B, 0x46, 0x32, 0x4B, 0x96,
+    0x35, 0xAD, 0x1F, 0xC2, 0xDF, 0x89, 0x17, 0xF6, 0xB6, 0xFA, 0xB5, 0xED, 0xB8, 0xB7, 0x8E, 0x78, 0x66, 0x96, 0x09,
+    0x6C, 0x6E, 0x23, 0x32, 0x28, 0x08, 0xE8, 0xF2, 0xBA, 0xF9, 0x86, 0x48, 0xC0, 0x68, 0xFE, 0x63, 0xC8, 0x23, 0x82,
+    0xCC, 0xA5, 0x4A, 0xFA, 0x66, 0x8F, 0xF0, 0x37, 0xE2, 0x6D, 0xE5, 0xC9, 0x3A, 0x87, 0x86, 0xB4, 0xFB, 0x28, 0xAE,
+    0x61, 0x0F, 0x0B, 0x59, 0xDF, 0xC0, 0xD1, 0xAC, 0xE0, 0x24, 0x41, 0x42, 0xC4, 0x49, 0x1B, 0x10, 0x21, 0x50, 0xC0,
+    0x09, 0x11, 0x8B, 0xEE, 0x6E, 0x71, 0xE2, 0xE2, 0x78, 0xBB, 0x33, 0xFA, 0xC5, 0x1A, 0xB4, 0xEA, 0xC6, 0x74, 0xD2,
+    0x8C, 0x24, 0xA5, 0x2A, 0x3C, 0xB5, 0x2E, 0xB9, 0x9B, 0x71, 0x97, 0x34, 0xE0, 0xAA, 0x54, 0x93, 0x71, 0x56, 0x49,
+    0xB9, 0xC6, 0x4E, 0x9A, 0x9B, 0xD3, 0xFA, 0x7F, 0x81, 0xB8, 0xD6, 0xAC, 0xDD, 0x6F, 0x65, 0x8D, 0x82, 0x77, 0x85,
+    0x95, 0xE1, 0x7D, 0x1C, 0xD2, 0x8B, 0x7A, 0x27, 0xA2, 0xF4, 0xED, 0xEE, 0x9E, 0x67, 0xE0, 0x8F, 0x81, 0x37, 0xBA,
+    0xEF, 0x87, 0x67, 0xBF, 0x8F, 0xC4, 0xD2, 0xDD, 0x4F, 0x05, 0xA8, 0x61, 0x7B, 0x1E, 0x9E, 0xE1, 0x8C, 0xEA, 0xF3,
+    0x18, 0x99, 0xA3, 0xDE, 0x76, 0x66, 0x36, 0x2A, 0x30, 0xFB, 0x9B, 0x0F, 0xC3, 0x1C, 0xA3, 0x76, 0x4B, 0xFB, 0x3B,
+    0xE8, 0xBA, 0x66, 0xBF, 0x0E, 0x93, 0xFD, 0xAB, 0x23, 0xD9, 0xA5, 0xCE, 0x62, 0xF3, 0x34, 0xEB, 0x7F, 0x29, 0x0A,
+    0xA7, 0x04, 0x48, 0xF2, 0x79, 0x82, 0x42, 0x1D, 0x46, 0x4B, 0xA9, 0x1B, 0xD1, 0xBE, 0x52, 0x54, 0xD7, 0xA8, 0xF8,
+    0x33, 0xE1, 0xAF, 0xC4, 0xA8, 0x24, 0xD6, 0x6D, 0xED, 0xBC, 0x0A, 0xD3, 0x5A, 0x5C, 0xC4, 0xDF, 0x64, 0x17, 0x97,
+    0x36, 0xF0, 0x65, 0x52, 0x39, 0xD4, 0x23, 0x22, 0x9D, 0xD8, 0x64, 0x83, 0x04, 0x85, 0x38, 0xEF, 0xB8, 0x49, 0x91,
+    0xBB, 0xFF, 0x00, 0x0A, 0xDF, 0xE3, 0x77, 0x84, 0xAC, 0xD3, 0x4A, 0xBC, 0xF0, 0x3A, 0x5A, 0x5B, 0x4F, 0x72, 0x5E,
+    0xD7, 0x53, 0x8E, 0xE2, 0x12, 0x6D, 0xC6, 0x40, 0x20, 0x47, 0xE6, 0x3E, 0x71, 0x26, 0x70, 0x24, 0xE4, 0xB4, 0x63,
+    0x2A, 0xC0, 0xE0, 0x7E, 0x71, 0x98, 0x71, 0x35, 0x5C, 0x4E, 0x69, 0x5A, 0xBD, 0x7C, 0x7A, 0x9C, 0xE3, 0xC9, 0xCF,
+    0x38, 0x46, 0x8D, 0xA4, 0xDC, 0x63, 0x38, 0x4A, 0xE9, 0xED, 0x5A, 0x4E, 0x4A, 0x6D, 0xF3, 0xCA, 0x2D, 0xB9, 0x4D,
+    0xD3, 0x77, 0x8C, 0x7F, 0xA8, 0xF8, 0x53, 0x8D, 0x31, 0x32, 0xC8, 0xA9, 0xDB, 0x15, 0x04, 0x9F, 0xB4, 0xD2, 0xF4,
+    0xD3, 0xF8, 0xA5, 0x77, 0xCD, 0xB3, 0x49, 0x6C, 0xB4, 0xEA, 0x97, 0x46, 0x78, 0x45, 0xC4, 0x16, 0x5A, 0xDD, 0xA5,
+    0xA6, 0x8D, 0xA7, 0xEA, 0x77, 0x4A, 0x54, 0x47, 0x3C, 0x31, 0x41, 0x20, 0x06, 0x68, 0x00, 0x9A, 0x4F, 0x2A, 0x40,
+    0x5D, 0x5F, 0x69, 0xF3, 0x15, 0xCB, 0x32, 0x96, 0xDC, 0xC0, 0x90, 0xA5, 0xF0, 0xBD, 0xAF, 0xC3, 0x96, 0x83, 0x51,
+    0xB8, 0xD6, 0xA7, 0x48, 0xD2, 0xE8, 0x2B, 0x2C, 0x2D, 0x6B, 0xF6, 0xA4, 0x55, 0x8E, 0x45, 0x5F, 0xBA, 0x54, 0x2A,
+    0x36, 0x77, 0x12, 0x72, 0xE5, 0x9C, 0x14, 0x3B, 0x63, 0x6C, 0x62, 0x8A, 0x2B, 0xDE, 0xCD, 0x70, 0x74, 0xA7, 0x92,
+    0xE2, 0x31, 0x35, 0x2D, 0x29, 0x54, 0xBB, 0x97, 0xBB, 0x18, 0xF3, 0x38, 0x52, 0xA5, 0x38, 0xDF, 0x92, 0x31, 0x7E,
+    0xEB, 0x9B, 0x6A, 0xCD, 0x6B, 0xEF, 0x7C, 0x6E, 0x52, 0x7F, 0xE1, 0xF7, 0x0E, 0x54, 0x96, 0x1B, 0x3D, 0x52, 0x86,
+    0xF0, 0x73, 0x4B, 0xEE, 0x92, 0xD6, 0xD6, 0xBF, 0xC2, 0x8D, 0x9F, 0x0B, 0xDE, 0xEB, 0xF3, 0x69, 0x6B, 0x06, 0x9B,
+    0xA9, 0x5B, 0xE9, 0xF6, 0x6F, 0x76, 0x1E, 0x45, 0x8E, 0xE1, 0x54, 0xC8, 0xCD, 0xF3, 0x28, 0x8B, 0x1C, 0x9E, 0x25,
+    0x55, 0xDA, 0xA5, 0x58, 0x80, 0xCA, 0x46, 0x42, 0xA8, 0xF4, 0x1B, 0xEB, 0xBB, 0xBB, 0x8B, 0x69, 0xAF, 0xA5, 0x8E,
+    0xD0, 0x49, 0x25, 0x9C, 0x37, 0x73, 0xE9, 0xD7, 0xF2, 0x14, 0x8E, 0x55, 0x91, 0x64, 0x90, 0x46, 0xA8, 0xF9, 0x50,
+    0x57, 0x73, 0x2E, 0xE0, 0x55, 0xF6, 0x87, 0x45, 0x20, 0x2E, 0xC7, 0x28, 0xAF, 0xCD, 0x78, 0xA6, 0xA5, 0x5C, 0x26,
+    0x33, 0x01, 0x35, 0x2E, 0x67, 0x52, 0x35, 0xA0, 0xEE, 0x93, 0x56, 0x70, 0x4F, 0x48, 0xDB, 0x95, 0x6B, 0x76, 0xF4,
+    0xB4, 0xA5, 0x27, 0x29, 0x29, 0x35, 0x16, 0xBF, 0xA8, 0x7C, 0x3E, 0x92, 0xF6, 0x98, 0xA8, 0x5B, 0x4B, 0xC5, 0xDB,
+    0x5E, 0x8E, 0x4F, 0x7D, 0xFA, 0xDB, 0x57, 0xB2, 0x56, 0xD6, 0xED, 0xF7, 0x3E, 0x10, 0xB2, 0x82, 0xF6, 0xC2, 0xF2,
+    0xF3, 0x4E, 0xD4, 0xAF, 0xEE, 0x5A, 0xCA, 0xCE, 0xD2, 0xF1, 0xA7, 0xB8, 0x9D, 0xD4, 0x42, 0x8C, 0xF2, 0x3C, 0x8E,
+    0x42, 0x02, 0x24, 0xFD, 0xDA, 0x96, 0x60, 0xAD, 0xB0, 0xC9, 0x0E, 0x00, 0xC8, 0xC8, 0xEA, 0xEE, 0x12, 0x7B, 0x09,
+    0x6C, 0x6E, 0xCE, 0xA2, 0x0B, 0xAA, 0x32, 0xD9, 0xB9, 0x49, 0x66, 0xDF, 0x74, 0xCC, 0x31, 0x1B, 0xE4, 0xE6, 0x63,
+    0xF2, 0x91, 0x95, 0x42, 0x15, 0x8B, 0x7D, 0xE0, 0xAC, 0xB4, 0x51, 0x5F, 0x33, 0x3A, 0xD8, 0x8C, 0x46, 0x7A, 0x9C,
+    0xA6, 0xD7, 0x2C, 0x13, 0x49, 0x25, 0x6E, 0x6A, 0x73, 0xE4, 0x84, 0x9E, 0x9A, 0xC9, 0x29, 0x24, 0x9E, 0xE9, 0x42,
+    0x11, 0x8D, 0xA2, 0x9C, 0x5F, 0xF5, 0x37, 0x0D, 0x36, 0xF8, 0x7E, 0x9A, 0xEC, 0xE5, 0xE5, 0x7E, 0x67, 0x77, 0x7B,
+    0x7A, 0xBF, 0x5E, 0xB7, 0x3F, 0xFF, 0xD9,
+};
+
+// 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,
+    0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x10, 0x0B, 0x0C, 0x0E, 0x0C, 0x0A, 0x10, 0x0E, 0x0D, 0x0E, 0x12, 0x11, 0x10,
+    0x13, 0x18, 0x28, 0x1A, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25, 0x1D, 0x28, 0x3A, 0x33, 0x3D, 0x3C, 0x39, 0x33,
+    0x38, 0x37, 0x40, 0x48, 0x5C, 0x4E, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6D, 0x51, 0x57, 0x5F, 0x62, 0x67,
+    0x68, 0x67, 0x3E, 0x4D, 0x71, 0x79, 0x70, 0x64, 0x78, 0x5C, 0x65, 0x67, 0x63, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x11,
+    0x12, 0x12, 0x18, 0x15, 0x18, 0x2F, 0x1A, 0x1A, 0x2F, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0xFF, 0xC2, 0x00, 0x11, 0x08, 0x00, 0x08, 0x00, 0x08, 0x03, 0x01, 0x22, 0x00,
+    0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x15, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xFF, 0xC4, 0x00, 0x15, 0x01, 0x01, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0xFF, 0xDA, 0x00, 0x0C, 0x03,
+    0x01, 0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00, 0x01, 0x94, 0x05, 0x3F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x01, 0x05, 0x02, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3F,
+    0x01, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3F, 0x01, 0x7F, 0xFF, 0xC4, 0x00,
+    0x14, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0xDA, 0x00, 0x08, 0x01, 0x01, 0x00, 0x06, 0x3F, 0x02, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x01, 0x3F, 0x21, 0x7F, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x10, 0x0B, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xC4, 0x00,
+    0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0xDA, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xD9,
+};
+
+class SourceImage : public RuntimeImage {
+ public:
+  explicit SourceImage(image::ImageType type = image::IMAGE_TYPE_RGB, int width = 0, int height = 0)
+      : RuntimeImage(JPEG, type, image::TRANSPARENCY_OPAQUE, nullptr, false, width, height) {}
+  size_t decoded_bytes() const { return this->decoded_bytes_; }
+};
+
+/// The file in memory; fails reads once fail_at bytes have been read
+class MemorySource : public DecodeSource {
+ public:
+  MemorySource(const uint8_t *data, size_t size, size_t fail_at = SIZE_MAX)
+      : data_(data), size_(size), fail_at_(fail_at) {}
+  int32_t read(uint8_t *buf, uint32_t len) override {
+    if (this->pos_ >= this->fail_at_)
+      return -1;
+    const size_t n = std::min<size_t>(len, this->size_ - this->pos_);
+    memcpy(buf, this->data_ + this->pos_, n);
+    this->pos_ += n;
+    this->reads++;
+    return static_cast<int32_t>(n);
+  }
+  bool seek(uint32_t position) override {
+    if (position > this->size_)
+      return false;
+    this->pos_ = position;
+    return true;
+  }
+  int reads{0};
+
+ protected:
+  const uint8_t *data_;
+  size_t size_;
+  size_t pos_{0};
+  size_t fail_at_;
+};
+
+/// Hands out only the bytes delivered so far, like a download that is still arriving
+class TrickleSource : public DecodeSource {
+ public:
+  TrickleSource(const uint8_t *data, size_t size, size_t delivered) : data_(data), size_(size), delivered_(delivered) {}
+  int32_t read(uint8_t *buf, uint32_t len) override {
+    const size_t n = std::min<size_t>(len, this->delivered_ - this->pos_);
+    memcpy(buf, this->data_ + this->pos_, n);
+    this->pos_ += n;
+    return static_cast<int32_t>(n);
+  }
+  bool seek(uint32_t position) override {
+    if (position > this->delivered_)
+      return false;
+    this->pos_ = position;
+    return true;
+  }
+  void deliver(size_t len) { this->delivered_ = std::min(this->size_, this->delivered_ + len); }
+
+ protected:
+  const uint8_t *data_;
+  size_t size_;
+  size_t delivered_;
+  size_t pos_{0};
+};
+
+static bool decode_fed(RuntimeImage &img) {
+  std::vector<uint8_t> buffer(JPEG_ROWS, JPEG_ROWS + sizeof(JPEG_ROWS));
+  if (!img.begin_decode(buffer.size()))
+    return false;
+  if (img.feed_data(buffer.data(), buffer.size()) != static_cast<int>(buffer.size()))
+    return false;
+  return img.end_decode();
+}
+
+/// Decodes from a source a step at a time; returns the last result and counts the steps
+static int decode_stepped(RuntimeImage &img, DecodeSource &source, int &steps) {
+  steps = 0;
+  if (!img.begin_decode(sizeof(JPEG_ROWS)) || !img.decoder_supports_source())
+    return DECODE_ERROR_UNSUPPORTED_FORMAT;
+  int result = img.begin_source(&source);
+  if (result != 0)
+    return result;
+  do {
+    result = img.decode_step();
+    steps++;
+  } while (result == DECODE_STEP_MORE);
+  if (result == DECODE_STEP_DONE && !img.end_decode())
+    return DECODE_ERROR_INTERNAL_DECODER_ERROR;
+  return result;
+}
+
+static std::vector<uint8_t> pixels(const RuntimeImage &img) {
+  const uint8_t *start = img.get_data_start();
+  return std::vector<uint8_t>(start, start + img.get_width_stride() * img.get_height());
+}
+
+TEST(JpegSourceDecode, SteppedDecodeMatchesFedDecode) {
+  SourceImage fed;
+  ASSERT_TRUE(decode_fed(fed));
+
+  SourceImage stepped;
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  int steps;
+  ASSERT_EQ(decode_stepped(stepped, source, steps), DECODE_STEP_DONE);
+  EXPECT_EQ(steps, 3);
+  ASSERT_EQ(stepped.get_width(), 48);
+  ASSERT_EQ(stepped.get_height(), 40);
+  EXPECT_EQ(pixels(stepped), pixels(fed));
+}
+
+TEST(JpegSourceDecode, SteppedDirectRgb565MatchesFedDecode) {
+  // A fixed size that is not a whole multiple of the source exercises the scaling tables across steps
+  SourceImage fed(image::IMAGE_TYPE_RGB565, 30, 25);
+  ASSERT_TRUE(decode_fed(fed));
+
+  SourceImage stepped(image::IMAGE_TYPE_RGB565, 30, 25);
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  int steps;
+  ASSERT_EQ(decode_stepped(stepped, source, steps), DECODE_STEP_DONE);
+  EXPECT_EQ(pixels(stepped), pixels(fed));
+}
+
+TEST(JpegSourceDecode, WaitsForDataThatHasNotArrived) {
+  SourceImage fed;
+  ASSERT_TRUE(decode_fed(fed));
+
+  // Enough for the headers (the scan starts at byte 609), then 50 bytes between steps
+  SourceImage img;
+  TrickleSource source(JPEG_ROWS, sizeof(JPEG_ROWS), 700);
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_ROWS)));
+  ASSERT_EQ(img.begin_source(&source), 0);
+  int waits = 0;
+  int result;
+  while ((result = img.decode_step()) == DECODE_STEP_MORE || result == DECODE_STEP_NEED_DATA) {
+    if (result == DECODE_STEP_NEED_DATA)
+      waits++;
+    source.deliver(50);
+    ASSERT_LT(waits, 1000);
+  }
+  ASSERT_EQ(result, DECODE_STEP_DONE);
+  ASSERT_TRUE(img.end_decode());
+  EXPECT_GT(waits, 0);
+  EXPECT_EQ(pixels(img), pixels(fed));
+}
+
+TEST(JpegSourceDecode, ImageIsHiddenUntilTheLastStep) {
+  SourceImage img;
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_ROWS)));
+  ASSERT_EQ(img.begin_source(&source), 0);
+  EXPECT_EQ(img.decode_step(), DECODE_STEP_MORE);
+  EXPECT_EQ(img.get_width(), 0);
+  EXPECT_EQ(img.get_data_start(), nullptr);
+}
+
+TEST(JpegSourceDecode, ReadFailureIsReportedAndTheDecoderRecovers) {
+  SourceImage img;
+  // The first read fills JPEGDEC's buffer, so the failure comes part way through the image data
+  MemorySource failing(JPEG_ROWS, sizeof(JPEG_ROWS), 2048);
+  int steps;
+  EXPECT_EQ(decode_stepped(img, failing, steps), DECODE_ERROR_READ);
+  EXPECT_GE(steps, 1);
+  img.release();
+
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  EXPECT_EQ(decode_stepped(img, source, steps), DECODE_STEP_DONE);
+}
+
+TEST(JpegSourceDecode, ReleasePartWayThroughLetsTheNextDecodeStart) {
+  SourceImage img;
+  MemorySource first(JPEG_ROWS, sizeof(JPEG_ROWS));
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_ROWS)));
+  ASSERT_EQ(img.begin_source(&first), 0);
+  ASSERT_EQ(img.decode_step(), DECODE_STEP_MORE);
+  img.release();
+  EXPECT_FALSE(img.is_decoding());
+
+  MemorySource second(JPEG_ROWS, sizeof(JPEG_ROWS));
+  int steps;
+  EXPECT_EQ(decode_stepped(img, second, steps), DECODE_STEP_DONE);
+  EXPECT_EQ(steps, 3);
+}
+
+TEST(JpegSourceDecode, FailedFirstReadIsAReadError) {
+  SourceImage img;
+  MemorySource failing(JPEG_ROWS, sizeof(JPEG_ROWS), 0);
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_ROWS)));
+  EXPECT_EQ(img.begin_source(&failing), DECODE_ERROR_READ);
+}
+
+TEST(JpegSourceDecode, FailedSeekToTheStartIsAReadError) {
+  class NoSeekSource : public MemorySource {
+   public:
+    using MemorySource::MemorySource;
+    bool seek(uint32_t position) override { return false; }
+  };
+  SourceImage img;
+  NoSeekSource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_ROWS)));
+  EXPECT_EQ(img.begin_source(&source), DECODE_ERROR_READ);
+  EXPECT_EQ(img.decode_step(), DECODE_ERROR_INVALID_TYPE);
+}
+
+TEST(JpegSourceDecode, ProgressiveImageIsUnsupported) {
+  SourceImage img;
+  MemorySource source(JPEG_PROGRESSIVE, sizeof(JPEG_PROGRESSIVE));
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_PROGRESSIVE)));
+  EXPECT_EQ(img.begin_source(&source), DECODE_ERROR_UNSUPPORTED_FORMAT);
+  EXPECT_EQ(img.decode_step(), DECODE_ERROR_INVALID_TYPE);
+}
+
+TEST(JpegSourceDecode, CompletedDecodeCountsTheWholeImage) {
+  SourceImage img;
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_ROWS)));
+  ASSERT_EQ(img.begin_source(&source), 0);
+  int result;
+  while ((result = img.decode_step()) == DECODE_STEP_MORE) {
+    EXPECT_EQ(img.decoded_bytes(), 0u);
+  }
+  ASSERT_EQ(result, DECODE_STEP_DONE);
+  EXPECT_EQ(img.decoded_bytes(), sizeof(JPEG_ROWS));
+}
+
+TEST(JpegSourceDecode, SourceIsReadAsTheDecodeNeedsIt) {
+  SourceImage img;
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  int steps;
+  ASSERT_EQ(decode_stepped(img, source, steps), DECODE_STEP_DONE);
+  EXPECT_GE(source.reads, 2);
+}
+
+TEST(JpegSourceDecode, DecodersThatCannotReadASourceSaySo) {
+  RuntimeImage img(BMP, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+  ASSERT_TRUE(img.begin_decode(100));
+  EXPECT_FALSE(img.decoder_supports_source());
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  EXPECT_EQ(img.begin_source(&source), DECODE_ERROR_UNSUPPORTED_FORMAT);
+  EXPECT_EQ(img.decode_step(), DECODE_ERROR_UNSUPPORTED_FORMAT);
+}
+
+TEST(JpegSourceDecode, SourceNeedsTheImageSize) {
+  SourceImage img;
+  MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+  // JPEGDEC needs the file size up front, and holds it in an int
+  ASSERT_TRUE(img.begin_decode(0));
+  EXPECT_EQ(img.begin_source(&source), DECODE_ERROR_INVALID_TYPE);
+  img.release();
+  ASSERT_TRUE(img.begin_decode(static_cast<size_t>(INT32_MAX) + 1));
+  EXPECT_EQ(img.begin_source(&source), DECODE_ERROR_INVALID_TYPE);
+}
+
+TEST(JpegSourceDecode, StepWithoutADecodeIsRefused) {
+  SourceImage img;
+  EXPECT_EQ(img.decode_step(), DECODE_ERROR_INVALID_TYPE);
+  ASSERT_TRUE(img.begin_decode(sizeof(JPEG_ROWS)));
+  // begin_source() was never called
+  EXPECT_EQ(img.decode_step(), DECODE_ERROR_INVALID_TYPE);
+}
+
+}  // namespace esphome::runtime_image::testing
+
+#endif  // USE_RUNTIME_IMAGE_JPEG
@@ -22,18 +22,5 @@ api:
        value: int
      then:
        - logger.log: "Plain action called"
-    - action: optional_args_action
-      variables:
-        song_str:
-          type: string
-          required: false
-        octave:
-          type: int
-          default: 5
-        loud:
-          type: bool
-          default: true
-      then:
-        - logger.log: "Optional action called"

 logger:
@@ -9,7 +9,6 @@ from __future__ import annotations
 import asyncio
 from collections import Counter
 import socket
-import struct
 from typing import Self

 from aioesphomeapi import api_pb2
@@ -50,36 +49,6 @@ def decode_varint(buf: bytearray, pos: int) -> tuple[int, int] | None:
    return None


-WIRE_VARINT, WIRE_LENGTH, WIRE_FIXED32 = 0, 2, 5
-
-
-def tag(field: int, wire_type: int) -> bytes:
-    return encode_varint((field << 3) | wire_type)
-
-
-def decode_fields(payload: bytes) -> dict[int, list[int | bytes]]:
-    """Split a protobuf payload into field number -> raw values; a test reads fields the client lacks."""
-    fields: dict[int, list[int | bytes]] = {}
-    buf = bytearray(payload)
-    pos = 0
-    while pos < len(buf):
-        key, pos = decode_varint(buf, pos)
-        field, wire_type = key >> 3, key & 0x07
-        if wire_type == WIRE_VARINT:
-            value, pos = decode_varint(buf, pos)
-        elif wire_type == WIRE_LENGTH:
-            length, pos = decode_varint(buf, pos)
-            value = bytes(buf[pos : pos + length])
-            pos += length
-        elif wire_type == WIRE_FIXED32:
-            value = struct.unpack_from("<I", buf, pos)[0]
-            pos += 4
-        else:
-            raise AssertionError(f"unexpected wire type {wire_type} for field {field}")
-        fields.setdefault(field, []).append(value)
-    return fields
-
-
 def encode_frame(msg_type: int, payload: bytes) -> bytes:
    """Encode one plaintext api frame: 0x00, payload length, message type."""
    return b"\x00" + encode_varint(len(payload)) + encode_varint(msg_type) + payload
@@ -38,7 +38,7 @@ async def test_api_action_metadata(
        _, services = await client.list_entities_services()

        by_name = {service.name: service for service in services}
-        assert set(by_name) == {"play_buzzer", "plain_action", "optional_args_action"}
+        assert set(by_name) == {"play_buzzer", "plain_action"}
        # Keys are hashed at codegen time and must match what the client expects
        for name, service in by_name.items():
            assert service.key == fnv1_hash(name), name
@@ -57,17 +57,6 @@ async def test_api_action_metadata(
        assert plain.description == ""
        assert plain.args[0].description == ""

-        # Optional flags and defaults, as (optional, default) per argument
-        def flags(service) -> dict[str, tuple[bool, str]]:
-            return {arg.name: (arg.optional, arg.default_value) for arg in service.args}
-
-        assert flags(plain) == {"value": (False, "")}
-        assert flags(by_name["optional_args_action"]) == {
-            "song_str": (True, ""),
-            "octave": (True, "5"),
-            "loud": (True, "true"),
-        }
-
        await client.execute_service(
            buzzer, {"song_str": "two_short:d=4,o=5,b=100:16e6,16e6", "volume": 3}
        )
@@ -10,26 +10,47 @@ from aioesphomeapi import CoverInfo, CoverState, EntityState, api_pb2
 import pytest

 from .log_utils import LineWaiter
-from .raw_api_client import (
-    MESSAGE_TYPE_OF,
-    WIRE_FIXED32,
-    WIRE_VARINT,
-    RawApiClient,
-    decode_fields,
-    tag,
-)
+from .raw_api_client import MESSAGE_TYPE_OF, RawApiClient, decode_varint, encode_varint
 from .state_utils import InitialStateHelper, StateWaiter, require_entity
 from .types import APIClientConnectedFactory, RunCompiledFunction

 COVER_COMMAND = MESSAGE_TYPE_OF[api_pb2.CoverCommandRequest]
 LIST_COVER = MESSAGE_TYPE_OF[api_pb2.ListEntitiesCoverResponse]
 LIST_DONE = MESSAGE_TYPE_OF[api_pb2.ListEntitiesDoneResponse]
+WIRE_VARINT, WIRE_LENGTH, WIRE_FIXED32 = 0, 2, 5
 # ListEntitiesCoverResponse fields; the installed client library does not know supports_toggle yet
 FIELD_ENTITY_KEY, FIELD_SUPPORTS_TOGGLE = 2, 15
 # CoverCommandRequest fields
 FIELD_KEY, FIELD_STOP, FIELD_TOGGLE = 1, 8, 11


+def tag(field: int, wire_type: int) -> bytes:
+    return encode_varint((field << 3) | wire_type)
+
+
+def decode_fields(payload: bytes) -> dict[int, list[int | bytes]]:
+    """Split a protobuf payload into field number -> raw values."""
+    fields: dict[int, list[int | bytes]] = {}
+    buf = bytearray(payload)
+    pos = 0
+    while pos < len(buf):
+        key, pos = decode_varint(buf, pos)
+        field, wire_type = key >> 3, key & 0x07
+        if wire_type == WIRE_VARINT:
+            value, pos = decode_varint(buf, pos)
+        elif wire_type == WIRE_LENGTH:
+            length, pos = decode_varint(buf, pos)
+            value = bytes(buf[pos : pos + length])
+            pos += length
+        elif wire_type == WIRE_FIXED32:
+            value = struct.unpack_from("<I", buf, pos)[0]
+            pos += 4
+        else:
+            raise AssertionError(f"unexpected wire type {wire_type} for field {field}")
+        fields.setdefault(field, []).append(value)
+    return fields
+
+
@pytest.mark.asyncio
 async def test_api_cover_toggle(
    yaml_config: str,
@@ -16,19 +16,16 @@ from aioesphomeapi import (
 )
 import pytest

-from .raw_api_client import (
-    MESSAGE_TYPE_OF,
-    WIRE_FIXED32,
-    WIRE_LENGTH,
-    WIRE_VARINT,
-    RawApiClient,
-    encode_varint,
-    tag,
-)
+from .raw_api_client import MESSAGE_TYPE_OF, RawApiClient, encode_varint
 from .state_utils import InitialStateHelper, StateWaiter, require_entity
 from .types import APIClientConnectedFactory, RunCompiledFunction

 SWITCH_COMMAND = MESSAGE_TYPE_OF[api_pb2.SwitchCommandRequest]
+WIRE_VARINT, WIRE_LENGTH, WIRE_FIXED32 = 0, 2, 5
+
+
+def tag(field: int, wire_type: int) -> bytes:
+    return encode_varint((field << 3) | wire_type)


@pytest.mark.asyncio
Author	SHA1	Message	Date
clyde	52c4c0310d	Merge branch 'runtime-image-integer-draw' into runtime-image-gray-integer	2026-10-22 22:03:59 +11:00
clyde	547dbf18d4	Merge branch 'runtime-image-jpeg-scale' into runtime-image-integer-draw	2026-10-22 22:03:58 +11:00
clyde	ba3af07a23	Merge branch 'online-image-progress' into runtime-image-jpeg-scale	2026-10-22 22:03:58 +11:00
clyde	9c6ae9c615	Merge branch 'online-image-jpeg-stream' into online-image-progress	2026-10-22 22:03:58 +11:00
clyde	de02ef8555	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 22:03:57 +11:00
clydeandClaude Opus 5.5	38b23152f4	[runtime_image] Put the is_finished() doc back above is_finished() Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 22:03:51 +11:00
clydeandClaude Opus 5.5	0849e4b412	[runtime_image] Work out grayscale pixels with integer maths Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 21:56:41 +11:00
clyde	375e8bc39b	Merge branch 'runtime-image-jpeg-scale' into runtime-image-integer-draw	2026-10-22 21:44:49 +11:00
clyde	16a91ab760	Merge branch 'online-image-progress' into runtime-image-jpeg-scale	2026-10-22 21:44:44 +11:00
clydeandClaude Opus 5.5	2456e8d686	[online_image] Use emplace_back in the download started test Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 21:44:39 +11:00
clyde	0c8e1c3f1c	Merge branch 'runtime-image-jpeg-scale' into runtime-image-integer-draw	2026-10-22 21:35:06 +11:00
clyde	a3c575d643	Merge branch 'online-image-progress' into runtime-image-jpeg-scale	2026-10-22 21:31:12 +11:00
clydeandClaude Opus 5.5	0573c8b568	[online_image] Add on_download_started Fires when the server has accepted the request and the image starts to download, before the first on_download_progress; not for a 304 or an HTTP error. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 21:24:05 +11:00
clyde	d01205fa62	Merge branch 'runtime-image-jpeg-steps' into runtime-image-jpeg-scale	2026-10-22 21:17:21 +11:00
clyde	de7ea89d0b	Merge branch 'online-image-jpeg-stream' into online-image-progress	2026-10-22 21:17:19 +11:00
clyde	0077f68158	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 21:17:18 +11:00
clydeandClaude Opus 5.5	7458f8c7d8	[runtime_image] Pin JPEGDEC to 1.8.4-esphome.3, built with -O2 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 21:17:13 +11:00
clyde	0e5e0a8ff6	Merge remote-tracking branch 'upstream/dev' into runtime-image-jpeg-steps	2026-10-22 21:15:57 +11:00
clydeandClaude Opus 5.5	752c230405	[runtime_image] Check once per draw() call whether the image is scaled An image drawn at its own size needs no span maths at all. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 21:14:33 +11:00
clydeandClaude Opus 5.5	cfc92657a2	[runtime_image] Say the generic draw() path keeps the same pixels as the RGB565 path Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 20:51:14 +11:00
clydeandClaude Opus 5.5	32f32f144d	[runtime_image] Skip the span division for an image drawn at its own size Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 20:44:48 +11:00
clydeandClaude Opus 5.5	9b60e7cff2	[runtime_image] Decode a JPEG at the smallest JPEGDEC scale that covers the buffer JPEGDEC can decode at 1/2, 1/4 or 1/8 size for much less work, but every JPEG was decoded at full size and then shrunk to the buffer. A 3596 x 2840 image shown at 281 x 222 took 7.1 s on an ESP32-S3; at 1/8 size it takes 2.0 s. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 20:19:44 +11:00
clydeandClaude Opus 5.5	02b8db1f3f	[runtime_image] Draw each target pixel once, with integer maths ImageDecoder::draw() painted every source pixel into the buffer, so a shrunk image wrote each target pixel many times, and worked out the spans with double multiplications and ceil() for every pixel. The S3 has no double FPU, so drawing took about 6 us a pixel: 3.7 s of a 1000 x 617 PNG's 6 s. Give each source pixel the span from ceil(start * scale) to ceil(end * scale), worked out with integers, so neighbouring spans meet without overlapping. The PNG now loads in 3.2 s. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 20:17:27 +11:00
clyde	f860c8a8d9	Merge branch 'online-image-jpeg-stream' into online-image-progress	2026-10-22 20:13:39 +11:00
clyde	bb7a060138	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 20:13:38 +11:00
clydeandClaude Opus 5.5	84839507bd	[runtime_image] Pin JPEGDEC to 1.8.4-esphome.2, with the ESP32-S3 SIMD under ESP-IDF Full-size JPEG decodes are 12-19% faster on an ESP32-S3 with ESP-IDF. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 20:13:33 +11:00
clyde	ef54eb14d8	Merge branch 'online-image-jpeg-stream' into online-image-progress	2026-10-22 16:29:02 +11:00
clydeandClaude Opus 5.5	60aa3e24f1	[online_image] Brace the whole-file fallback for clang-tidy Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 16:29:01 +11:00
clyde	63566999bd	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 16:28:45 +11:00
clydeandClaude Opus 5.5	1728d3326b	[runtime_image] Log a failed open from a source at debug level, as the caller may recover Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 16:28:44 +11:00
clyde	2b99c56754	Merge branch 'online-image-jpeg-stream' into online-image-progress	2026-10-22 16:21:09 +11:00
clydeandClaude Opus 5.5	d79cd9a7eb	[online_image] Download the whole JPEG when its headers do not fit the buffer Before JPEG images were decoded as they download, the buffer grew to hold the whole file, so an image with large EXIF or ICC data decoded with any buffer_size. Keep that working: when the headers do not fit, grow the buffer to the file size, keeping what has arrived, and decode it at the end as before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 16:21:08 +11:00
clyde	fa18994fab	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 16:19:20 +11:00
clydeandClaude Opus 5.5	1090706216	[runtime_image] Count the bytes of a stepped decode, and say when begin_source() can be called Report any failed read of the source as DECODE_ERROR_READ from one place. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 16:19:01 +11:00
clydeandClaude Opus 5.5	ced497995d	[online_image] Add on_download_progress, to show how far a download has got Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 14:35:37 +11:00
clydeandClaude Opus 5.5	228c553f60	[online_image] Also give the buffer_size hint when unreadable headers end in a read error Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 14:34:15 +11:00
clydeandClaude Opus 5.5	563e197c6d	[online_image] Open a streamed JPEG in a pass of its own, and only blame the buffer for unreadable headers Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 14:29:07 +11:00
clyde	9d07f1f400	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 14:27:47 +11:00
clydeandClaude Opus 5.5	846fc70bdf	[runtime_image] Report a progressive JPEG as an unsupported format Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 14:27:46 +11:00
clyde	74212d8d04	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 13:41:53 +11:00
clydeandClaude Opus 5.5	101c9cd840	[runtime_image] Take JPEGDEC from esphome-libs Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 13:41:48 +11:00
clyde	8152dcf224	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 13:37:13 +11:00
clydeandClaude Opus 5.5	f2d50b4aa7	[runtime_image] Drop the trailing underscore from the static JPEGDEC callbacks Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 13:37:13 +11:00
clydeandClaude Opus 5.5	f75b3d6ded	[online_image] Test decode and read errors part way through a streamed JPEG Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 13:17:00 +11:00
clyde	3cf29bf4fb	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 13:14:54 +11:00
clydeandClaude Opus 5.5	f752e3b150	[runtime_image] Report a failed seek to the start as a read error Also limit the JPEGDEC pin comment to the fixes ESPHome uses: it never crops, and refuses progressive images. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 13:14:51 +11:00
clyde	a5bc7070d1	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 13:06:41 +11:00
clydeandClaude Opus 5.5	b2eebfb010	[runtime_image] Pin JPEGDEC to the 1.8.4-esphome.1 release Adds the upstream fix that skips building AC Huffman tables for progressive images. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 13:06:37 +11:00
clyde	a596d1d3c8	Merge branch 'runtime-image-jpeg-steps' into online-image-jpeg-stream	2026-10-22 09:09:13 +11:00
clydeandClaude Opus 5.5	6701aedae2	[runtime_image] Pin JPEGDEC with the grayscale, crop and progressive fixes A grayscale JPEG decoded for any image type but direct RGB565 came out garbled: JPEGDEC wrote RGB565 words where it was asked for RGB8888. The new pin fixes that, along with cropping and a crash on progressive images with skipped blocks, which ESPHome does not use. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 09:09:09 +11:00
clydeandClaude Opus 5.5	6fddbd1d48	[online_image] Decode a JPEG as it downloads A JPEG had to be downloaded whole, into a buffer grown to the file size, and was then decoded in one call. When the server gives the size, the JPEG decoder now reads the download from the buffer itself and decodes a row of MCUs at a time, within a time budget per loop pass. The buffer only has to hold the headers, so buffer_size bounds the RAM used, and a slow link makes the decoder wait for the rest rather than decode past what has arrived. Downloads without a size keep the old path. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 07:23:28 +11:00
clydeandClaude Opus 5.5	03aaa00d75	[runtime_image] Refuse a source decode without a usable image size JPEGDEC needs the file size when it opens a source, and holds it in an int. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 07:21:14 +11:00
clydeandClaude Opus 5.5	b612eb2929	[runtime_image] Let a source-reading decoder wait for data that has not arrived A source that is still arriving, such as a download, may have nothing to give when the decoder asks for more. The pinned JPEGDEC now pauses before an MCU when less input is buffered than it needs and the source has no more yet, and decode_step() reports that as DECODE_STEP_NEED_DATA; the next call carries on. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 07:04:54 +11:00
clydeandClaude Opus 5.5	63c041a95b	[runtime_image] Pin JPEGDEC with the ARM NEON clipped MCU fix Upstream's fix for the NEON path writing past the end of a row on clipped MCUs, which overflows a framebuffer whose width is not a multiple of 16. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 22:36:44 +11:00
clydeandClaude Opus 5.5	f8d5096093	[runtime_image] Pin JPEGDEC with the ARM NEON colour order fix The NEON 4:2:0 RGB8888 path swapped red and blue (JPEGDEC PR 121), which shows on host builds on 64-bit ARM. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 22:26:39 +11:00
clydeandClaude Opus 5.5	f835600fa6	[runtime_image] Let a decoder read its input itself and decode JPEG a row at a time JPEGDEC decodes a whole image in one call, from a copy of the whole file in RAM. A JPEGDEC that can stop between rows (1.8.4 plus decodeBegin() and decodeRows(), pinned from a fork for now) lets the JPEG decoder read a DecodeSource itself, through JPEGDEC's own 2 KB buffer, and decode one row of MCUs per decode_step(). A component that can read its input on demand, such as a file, no longer needs a buffer for the whole file or a main loop pass long enough to decode the image. Decoders that cannot read a source say so, and the fed decode() path is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 22:08:01 +11:00