Merge pull request #20 from strange-v/dev

strange-v · web-flow · commit 271487abba30 · 2025-11-19T09:21:32.000+01:00
HW decoding on ESP32-P4 and bug-fixes
diff --git a/components/remote_webview/idf_component.yml b/components/remote_webview/idf_component.yml
@@ -3,3 +3,11 @@ dependencies:
   - espressif/esp_websocket_client
   - espressif/esp-dsp
   - jpegdec
+
+  - esp_driver_jpeg:
+    require: private
+    rules: [ { if: target == "esp32p4" } ]
+
+  - esp_mm:
+    require: private
+    rules: [ { if: target == "esp32p4" } ]
diff --git a/components/remote_webview/remote_webview.cpp b/components/remote_webview/remote_webview.cpp
@@ -9,13 +9,14 @@
 #include "esp_timer.h"
 #include "esp_heap_caps.h"
 #include "esp_websocket_client.h"
+#include "esp_efuse.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 
 namespace esphome {
 namespace remote_webview {
 
-static const char *const TAG = "Remove_WebView";
+static const char *const TAG = "Remote_WebView";
 RemoteWebView *RemoteWebView::self_ = nullptr;
 
 void RemoteWebView::setup() {
@@ -26,7 +27,10 @@ void RemoteWebView::setup() {
     return;
   }
 
-  q_decode_    = xQueueCreate(cfg::decode_queue_depth, sizeof(WsMsg));
+  display_width_ = display_->get_width();
+  display_height_ = display_->get_height();
+
+  q_decode_ = xQueueCreate(cfg::decode_queue_depth, sizeof(WsMsg));
   ws_send_mtx_ = xSemaphoreCreateMutex();
 
   start_decode_task_();
@@ -35,8 +39,45 @@ void RemoteWebView::setup() {
   if (touch_) {
     touch_listener_ = new RemoteWebViewTouchListener(this);
     touch_->register_listener(touch_listener_);
-    ESP_LOGI(TAG, "touch listener registered");
+    ESP_LOGD(TAG, "touch listener registered");
+  }
+
+#if REMOTE_WEBVIEW_HW_JPEG
+  jpeg_decode_engine_cfg_t jcfg = {
+    .timeout_ms = 200,
+  };
+  if (jpeg_new_decoder_engine(&jcfg, &hw_dec_) != ESP_OK) {
+    hw_dec_ = nullptr;
+  }
+  
+  if (hw_dec_) {
+    const int W = display_->get_width();
+    const int H = display_->get_height();
+    const int aligned_w = (W + 15) & ~15;
+    const int aligned_h = (H + 15) & ~15;
+    
+    const size_t max_buffer_size = (size_t)aligned_w * (size_t)aligned_h * 2u;
+    
+    jpeg_decode_memory_alloc_cfg_t in_cfg { .buffer_direction = JPEG_DEC_ALLOC_INPUT_BUFFER };
+    jpeg_decode_memory_alloc_cfg_t out_cfg { .buffer_direction = JPEG_DEC_ALLOC_OUTPUT_BUFFER };
+    
+    hw_decode_input_buf_ = (uint8_t*)jpeg_alloc_decoder_mem((uint32_t)max_buffer_size, &in_cfg, &hw_decode_input_size_);
+    hw_decode_output_buf_ = (uint8_t*)jpeg_alloc_decoder_mem((uint32_t)max_buffer_size, &out_cfg, &hw_decode_output_size_);
+    
+    if (!hw_decode_input_buf_ || !hw_decode_output_buf_) {
+      ESP_LOGE(TAG, "Failed to allocate HW decoder buffers");
+      if (hw_decode_input_buf_) free(hw_decode_input_buf_);
+      if (hw_decode_output_buf_) free(hw_decode_output_buf_);
+      hw_decode_input_buf_ = nullptr;
+      hw_decode_output_buf_ = nullptr;
+      jpeg_del_decoder_engine(hw_dec_);
+      hw_dec_ = nullptr;
+    } else {
+      ESP_LOGD(TAG, "HW decoder buffers allocated: input=%u, output=%u", 
+               (unsigned)hw_decode_input_size_, (unsigned)hw_decode_output_size_);
+    }
   }
+#endif
 }
 
 void RemoteWebView::dump_config() {
@@ -49,6 +90,12 @@ void RemoteWebView::dump_config() {
     ESP_LOGCONFIG(TAG, "  display: %dx%d", display_->get_width(), display_->get_height());
   }
 
+#if REMOTE_WEBVIEW_HW_JPEG
+  ESP_LOGCONFIG(TAG, "  hw_jpeg: %s", hw_dec_ ? "yes" : "no");
+#else
+  ESP_LOGCONFIG(TAG, "  hw_jpeg: no");
+#endif
+
   ESP_LOGCONFIG(TAG, "  server: %s:%d", server_host_.c_str(), server_port_);
   ESP_LOGCONFIG(TAG, "  url: %s", url_.c_str());
 
@@ -79,7 +126,7 @@ bool RemoteWebView::open_url(const std::string &s) {
   
   if (ws_send_open_url_(s.c_str(), 0)) {
     url_ = s;
-    ESP_LOGI(TAG, "opened URL: %s", s.c_str());
+    ESP_LOGD(TAG, "opened URL: %s", s.c_str());
     return true;
   }
   
@@ -145,7 +192,7 @@ void RemoteWebView::ws_event_handler_(void *handler_arg, esp_event_base_t, int32
 
     case WEBSOCKET_EVENT_DISCONNECTED:
       if (self_) self_->ws_client_ = nullptr;
-      ESP_LOGW(TAG, "[ws] disconnected");
+      ESP_LOGI(TAG, "[ws] disconnected");
       if (self_) self_->last_keepalive_us_ = 0; 
       reasm_reset_(*r);
       break;
@@ -160,8 +207,11 @@ void RemoteWebView::ws_event_handler_(void *handler_arg, esp_event_base_t, int32
 
       if (e->payload_offset == 0) {
         reasm_reset_(*r);
-        if ((size_t)e->payload_len > cfg::ws_max_message_bytes) {
-          ESP_LOGE(TAG, "WS message too large: %u > %u", (unsigned)e->payload_len, (unsigned)cfg::ws_max_message_bytes);
+        const size_t max_allowed = (self_ && self_->max_bytes_per_msg_ > 0) 
+                                   ? (size_t)self_->max_bytes_per_msg_ 
+                                   : cfg::ws_max_message_bytes;
+        if ((size_t)e->payload_len > max_allowed) {
+          ESP_LOGE(TAG, "WS message too large: %u > %u", (unsigned)e->payload_len, (unsigned)max_allowed);
           break;
         }
         r->total = (size_t)e->payload_len;
@@ -252,15 +302,12 @@ void RemoteWebView::process_frame_packet_(const uint8_t *data, size_t len)
   frame_bytes_ += len;
   frame_tiles_ += fi.tile_count;
 
-  const int FB_W = display_ ? display_->get_width()  : 480;
-  const int FB_H = display_ ? display_->get_height() : 480;
-
   for (uint16_t i = 0; i < fi.tile_count; i++) {
     proto::TileHeader th{};
     if (!proto::parse_tile_header(data, len, th, off)) return;
     if (off + th.dlen > len) return;
 
-    if (th.w == 0 || th.h == 0 || th.w > FB_W || th.h > FB_H) {
+    if (th.w == 0 || th.h == 0 || th.w > display_width_ || th.h > display_height_) {
       off += th.dlen;
       continue;
     }
@@ -270,7 +317,6 @@ void RemoteWebView::process_frame_packet_(const uint8_t *data, size_t len)
     }
     
     off += th.dlen;
-    taskYIELD();
   }
 
   if (fi.flags & proto::kFlafLastOfFrame) {
@@ -305,19 +351,68 @@ void RemoteWebView::process_frame_stats_packet_(const uint8_t *data, size_t len)
 }
 
 bool RemoteWebView::decode_jpeg_tile_to_lcd_(int16_t dst_x, int16_t dst_y, const uint8_t *data, size_t len) {
-  if (!display_ || !data || len == 0) return false;
+  if (!data || !len) return false;
 
+#if REMOTE_WEBVIEW_HW_JPEG
+  if (hw_dec_ && hw_decode_input_buf_ && hw_decode_output_buf_) {
+    jpeg_decode_picture_info_t hdr{};
+    if (jpeg_decoder_get_info(data, (uint32_t)len, &hdr) != ESP_OK || !hdr.width || !hdr.height) {
+      return decode_jpeg_tile_software_(dst_x, dst_y, data, len);
+    }
+
+    const int aligned_w = (hdr.width  + 15) & ~15;
+    const int aligned_h = (hdr.height + 15) & ~15;
+    const uint32_t out_sz = (uint32_t)aligned_w * (uint32_t)aligned_h * 2u;
+
+    if (aligned_w != (int)hdr.width) {
+      ESP_LOGW(TAG, "jpeg dimensions not aligned: %u x %u", (unsigned)hdr.width, (unsigned)hdr.height);
+      return decode_jpeg_tile_software_(dst_x, dst_y, data, len);
+    }
+    
+    if (len > hw_decode_input_size_ || out_sz > hw_decode_output_size_) {
+      ESP_LOGW(TAG, "tile too large for HW decoder buffers");
+      return decode_jpeg_tile_software_(dst_x, dst_y, data, len);
+    }
+
+    jpeg_decode_cfg_t jcfg{};
+    jcfg.output_format = JPEG_DECODE_OUT_FORMAT_RGB565;
+    jcfg.rgb_order     = JPEG_DEC_RGB_ELEMENT_ORDER_BGR;
+    jcfg.conv_std      = JPEG_YUV_RGB_CONV_STD_BT709;
+
+    memcpy(hw_decode_input_buf_, data, len);
+    
+    uint32_t written = 0;
+    esp_err_t dr = jpeg_decoder_process(hw_dec_, &jcfg, hw_decode_input_buf_, (uint32_t)len, 
+                                        hw_decode_output_buf_, (uint32_t)hw_decode_output_size_, &written);
+
+    if (dr != ESP_OK) {
+      return decode_jpeg_tile_software_(dst_x, dst_y, data, len);
+    }
+
+    display_->draw_pixels_at(dst_x, dst_y, (int)hdr.width, (int)hdr.height, hw_decode_output_buf_,
+        esphome::display::COLOR_ORDER_RGB,
+        esphome::display::COLOR_BITNESS_565,
+        rgb565_big_endian_);
+
+    return true;
+  }
+#endif  // REMOTE_WEBVIEW_HW_JPEG
+
+  return decode_jpeg_tile_software_(dst_x, dst_y, data, len);
+}
+
+bool RemoteWebView::decode_jpeg_tile_software_(int16_t dst_x, int16_t dst_y, const uint8_t *data, size_t len) {
   if (!jd_.openRAM((uint8_t*)data, (int)len, &RemoteWebView::jpeg_draw_cb_s_)) {
-    ESP_LOGW(TAG, "openRAM failed (len=%u) err=%d", (unsigned)len, jd_.getLastError());
+    ESP_LOGE(TAG, "openRAM failed (len=%u) err=%d", (unsigned)len, jd_.getLastError());
     return false;
   }
 
-  jd_.setMaxOutputSize(4 * 2048);
+  jd_.setMaxOutputSize(8 * 2048);
   jd_.setPixelType(rgb565_big_endian_ ? RGB565_BIG_ENDIAN : RGB565_LITTLE_ENDIAN);
 
   const int rc = jd_.decode(dst_x, dst_y, 0);
   if (rc == 0) {
-    ESP_LOGW(TAG, "decode rc=%d err=%d", rc, jd_.getLastError());
+    ESP_LOGE(TAG, "decode rc=%d err=%d", rc, jd_.getLastError());
     jd_.close();
     return false;
   }
@@ -330,24 +425,19 @@ int RemoteWebView::jpeg_draw_cb_s_(JPEGDRAW *p) {
 }
 
 int RemoteWebView::jpeg_draw_cb_(JPEGDRAW *p) {
-  if (!display_) return 0;
-
   int32_t x = p->x, y = p->y, w = p->iWidth, h = p->iHeight;
-  const int FB_W = display_->get_width();
-  const int FB_H = display_->get_height();
-
-  if (x >= FB_W || y >= FB_H) return 1;
-  if (x + w > FB_W) w = FB_W - x;
-  if (y + h > FB_H) h = FB_H - y;
+  
+  if (x >= display_width_ || y >= display_height_) return 1;
+  if (x + w > display_width_) w = display_width_ - x;
+  if (y + h > display_height_) h = display_height_ - y;
   if (w <= 0 || h <= 0) return 1;
 
-  const bool big_endian = rgb565_big_endian_;
   display_->draw_pixels_at(
       x, y, w, h,
       (const uint8_t *)p->pPixels,
       esphome::display::COLOR_ORDER_RGB,
       esphome::display::COLOR_BITNESS_565,
-      big_endian
+      rgb565_big_endian_
   );
 
   return 1;
@@ -357,7 +447,6 @@ bool RemoteWebView::ws_send_touch_event_(proto::TouchType type, int x, int y, ui
   if (!ws_client_ || !ws_send_mtx_ || !esp_websocket_client_is_connected(ws_client_))
     return false;
 
-  // clamp into 16-bit
   if (x < 0) x = 0; if (y < 0) y = 0;
   if (x > 65535) x = 65535; if (y > 65535) y = 65535;
 
@@ -384,10 +473,10 @@ bool RemoteWebView::ws_send_open_url_(const char *url, uint16_t flags) {
 
   const uint32_t n = (uint32_t) strlen(url);
   const size_t total = sizeof(proto::OpenURLHeader) + (size_t) n;
-  if (total > cfg::ws_max_message_bytes) return false;
+  
+  if (total > 16 * 1024) return false;
 
-  // try PSRAM first
-  auto *pkt = (uint8_t *) heap_caps_malloc(total, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+    auto *pkt = (uint8_t *) heap_caps_malloc(total, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
   if (!pkt) pkt = (uint8_t *) heap_caps_malloc(total, MALLOC_CAP_8BIT);
   if (!pkt) return false;
 
@@ -495,21 +584,31 @@ std::string RemoteWebView::resolve_device_id_() const {
   if (!device_id_.empty()) return device_id_;
 
   uint8_t mac[6] = {0};
+  esp_err_t err = ESP_FAIL;
+  
 #if ESP_IDF_VERSION_MAJOR >= 5
-  if (esp_read_mac(mac, ESP_MAC_WIFI_STA) != ESP_OK) {
-    (void) esp_read_mac(mac, ESP_MAC_BT);  // best-effort fallback
+  err = esp_read_mac(mac, ESP_MAC_WIFI_STA);
+  if (err != ESP_OK) {
+    err = esp_read_mac(mac, ESP_MAC_BT);
+  }
+  if (err != ESP_OK) {
+    err = esp_read_mac(mac, ESP_MAC_ETH);
+  }
+  if (err != ESP_OK) {
+    err = esp_efuse_mac_get_default(mac);
   }
 #else
-  // Older IDF: try to get base MAC from eFuse
-  // (some SDKs declare esp_efuse_mac_get_default in esp_system.h)
-  extern "C" esp_err_t esp_efuse_mac_get_default(uint8_t *mac);
-  if (esp_efuse_mac_get_default) {
-    (void) esp_efuse_mac_get_default(mac);
-  } else {
-    (void) esp_read_mac(mac, ESP_MAC_WIFI_STA);
+  err = esp_efuse_mac_get_default(mac);
+  if (err != ESP_OK) {
+    err = esp_read_mac(mac, ESP_MAC_WIFI_STA);
   }
 #endif
 
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Failed to read MAC address, using random ID");
+    snprintf((char*)mac, sizeof(mac), "%06lx", (unsigned long)esp_random());
+  }
+
   char buf[32];
   snprintf(buf, sizeof(buf), "esp32-%02x%02x%02x%02x%02x%02x",
            mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
@@ -524,10 +623,8 @@ std::string RemoteWebView::build_ws_uri_() const {
   const std::string id = resolve_device_id_();
   append_q_str_(uri, "id", id.c_str());
 
-  const int W = display_ ? display_->get_width()  : 0;
-  const int H = display_ ? display_->get_height() : 0;
-  append_q_int_(uri, "w", W);
-  append_q_int_(uri, "h", H);
+  append_q_int_(uri, "w", display_width_);
+  append_q_int_(uri, "h", display_height_);
 
   append_q_int_(uri,   "r",    rotation_);
   append_q_int_(uri,   "ts",   tile_size_);
diff --git a/components/remote_webview/remote_webview.h b/components/remote_webview/remote_webview.h
@@ -12,6 +12,19 @@
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
 
+#if defined(CONFIG_IDF_TARGET_ESP32P4)
+  #include "driver/jpeg_decode.h"
+  #define REMOTE_WEBVIEW_HW_JPEG 1
+#else
+  #define REMOTE_WEBVIEW_HW_JPEG 0
+#endif
+#if defined(CONFIG_IDF_TARGET_ESP32P4)
+  #include "esp_cache.h"
+  #define REMOTE_WEBVIEW_HAS_CACHE_MSYNC 1
+#else
+  #define REMOTE_WEBVIEW_HAS_CACHE_MSYNC 0
+#endif
+
 namespace esphome {
 namespace remote_webview {
 
@@ -58,6 +71,8 @@ class RemoteWebView : public Component {
   display::Display *display_{nullptr};
   touchscreen::Touchscreen *touch_ = nullptr;
   class RemoteWebViewTouchListener *touch_listener_ = nullptr;
+  int display_width_{0};
+  int display_height_{0};
   std::string url_;
   std::string server_host_;
   std::string device_id_;
@@ -73,6 +88,14 @@ class RemoteWebView : public Component {
   bool rgb565_big_endian_{true};
   int rotation_{0};
 
+#if REMOTE_WEBVIEW_HW_JPEG
+  jpeg_decoder_handle_t hw_dec_{nullptr};
+  uint8_t *hw_decode_input_buf_{nullptr};
+  uint8_t *hw_decode_output_buf_{nullptr};
+  size_t hw_decode_input_size_{0};
+  size_t hw_decode_output_size_{0};
+#endif
+
   uint64_t last_move_us_{0};
   uint64_t last_keepalive_us_{0};
   
@@ -103,6 +126,7 @@ class RemoteWebView : public Component {
   void process_frame_packet_(const uint8_t *data, size_t len);
   void process_frame_stats_packet_(const uint8_t *data, size_t len);
   bool decode_jpeg_tile_to_lcd_(int16_t dst_x, int16_t dst_y, const uint8_t *data, size_t len);
+  bool decode_jpeg_tile_software_(int16_t dst_x, int16_t dst_y, const uint8_t *data, size_t len);
 
   static int jpeg_draw_cb_s_(JPEGDRAW *p);
   int jpeg_draw_cb_(JPEGDRAW *p);
