[infrared, remote_base] Optimize IR transmit path for web_server base85 data (#13238)

esphome/components/infrared/infrared.cpp

@@ -18,7 +18,15 @@ InfraredCall &InfraredCall::set_carrier_frequency(uint32_t frequency) {
 
 InfraredCall &InfraredCall::set_raw_timings(const std::vector<int32_t> &timings) {
   this->raw_timings_ = &timings;
-  this->packed_data_ = nullptr;  // Clear packed if vector is set
+  this->packed_data_ = nullptr;
+  this->base85_ptr_ = nullptr;
+  return *this;
+}
+
+InfraredCall &InfraredCall::set_raw_timings_base85(const std::string &base85) {
+  this->base85_ptr_ = &base85;
+  this->raw_timings_ = nullptr;
+  this->packed_data_ = nullptr;
   return *this;
 }
 
@@ -26,7 +34,8 @@ InfraredCall &InfraredCall::set_raw_timings_packed(const uint8_t *data, uint16_t
   this->packed_data_ = data;
   this->packed_length_ = length;
   this->packed_count_ = count;
-  this->raw_timings_ = nullptr;  // Clear vector if packed is set
+  this->raw_timings_ = nullptr;
+  this->base85_ptr_ = nullptr;
   return *this;
 }
 
@@ -92,6 +101,14 @@ void Infrared::control(const InfraredCall &call) {
                                                call.get_packed_count());
     ESP_LOGD(TAG, "Transmitting packed raw timings: count=%u, repeat=%u", call.get_packed_count(),
              call.get_repeat_count());
+  } else if (call.is_base85()) {
+    // Decode base85 directly into transmit buffer (zero heap allocations)
+    if (!transmit_data->set_data_from_base85(call.get_base85_data())) {
+      ESP_LOGE(TAG, "Invalid base85 data");
+      return;
+    }
+    ESP_LOGD(TAG, "Transmitting base85 raw timings: count=%zu, repeat=%u", transmit_data->get_data().size(),
+             call.get_repeat_count());
   } else {
     // From vector (lambdas/automations)
     transmit_data->set_data(call.get_raw_timings());

esphome/components/infrared/infrared.h

@@ -28,12 +28,29 @@ class InfraredCall {
 
   /// Set the carrier frequency in Hz
   InfraredCall &set_carrier_frequency(uint32_t frequency);
-  /// Set the raw timings (positive = mark, negative = space)
-  /// Note: The timings vector must outlive the InfraredCall (zero-copy reference)
+
+  // ===== Raw Timings Methods =====
+  // All set_raw_timings_* methods store pointers/references to external data.
+  // The referenced data must remain valid until perform() completes.
+  // Safe pattern:   call.set_raw_timings_xxx(data); call.perform();  // synchronous
+  // Unsafe pattern: call.set_raw_timings_xxx(data); defer([call]() { call.perform(); });  // data may be gone!
+
+  /// Set the raw timings from a vector (positive = mark, negative = space)
+  /// @note Lifetime: Stores a pointer to the vector. The vector must outlive perform().
+  /// @note Usage: Primarily for lambdas/automations where the vector is in scope.
   InfraredCall &set_raw_timings(const std::vector<int32_t> &timings);
-  /// Set the raw timings from packed protobuf sint32 data (zero-copy from wire)
-  /// Note: The data must outlive the InfraredCall
+
+  /// Set the raw timings from base85-encoded int32 data
+  /// @note Lifetime: Stores a pointer to the string. The string must outlive perform().
+  /// @note Usage: For web_server where the encoded string is on the stack.
+  /// @note Decoding happens at perform() time, directly into the transmit buffer.
+  InfraredCall &set_raw_timings_base85(const std::string &base85);
+
+  /// Set the raw timings from packed protobuf sint32 data (zigzag + varint encoded)
+  /// @note Lifetime: Stores a pointer to the buffer. The buffer must outlive perform().
+  /// @note Usage: For API component where data comes directly from the protobuf message.
   InfraredCall &set_raw_timings_packed(const uint8_t *data, uint16_t length, uint16_t count);
+
   /// Set the number of times to repeat transmission (1 = transmit once, 2 = transmit twice, etc.)
   InfraredCall &set_repeat_count(uint32_t count);
 
@@ -42,12 +59,18 @@ class InfraredCall {
 
   /// Get the carrier frequency
   const optional<uint32_t> &get_carrier_frequency() const { return this->carrier_frequency_; }
-  /// Get the raw timings (only valid if set via set_raw_timings, not packed)
+  /// Get the raw timings (only valid if set via set_raw_timings, not packed or base85)
   const std::vector<int32_t> &get_raw_timings() const { return *this->raw_timings_; }
-  /// Check if raw timings have been set (either vector or packed)
-  bool has_raw_timings() const { return this->raw_timings_ != nullptr || this->packed_data_ != nullptr; }
+  /// Check if raw timings have been set (vector, packed, or base85)
+  bool has_raw_timings() const {
+    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base85_ptr_ != nullptr;
+  }
   /// Check if using packed data format
   bool is_packed() const { return this->packed_data_ != nullptr; }
+  /// Check if using base85 data format
+  bool is_base85() const { return this->base85_ptr_ != nullptr; }
+  /// Get the base85 data string
+  const std::string &get_base85_data() const { return *this->base85_ptr_; }
   /// Get packed data (only valid if set via set_raw_timings_packed)
   const uint8_t *get_packed_data() const { return this->packed_data_; }
   uint16_t get_packed_length() const { return this->packed_length_; }
@@ -59,9 +82,11 @@ class InfraredCall {
   uint32_t repeat_count_{1};
   Infrared *parent_;
   optional<uint32_t> carrier_frequency_;
-  // Vector-based timings (for lambdas/automations)
+  // Pointer to vector-based timings (caller-owned, must outlive perform())
   const std::vector<int32_t> *raw_timings_{nullptr};
-  // Packed protobuf timings (for API zero-copy)
+  // Pointer to base85-encoded string (caller-owned, must outlive perform())
+  const std::string *base85_ptr_{nullptr};
+  // Pointer to packed protobuf buffer (caller-owned, must outlive perform())
   const uint8_t *packed_data_{nullptr};
   uint16_t packed_length_{0};
   uint16_t packed_count_{0};

esphome/components/remote_base/remote_base.cpp

@@ -159,6 +159,10 @@ void RemoteTransmitData::set_data_from_packed_sint32(const uint8_t *data, size_t
   }
 }
 
+bool RemoteTransmitData::set_data_from_base85(const std::string &base85) {
+  return base85_decode_int32_vector(base85, this->data_);
+}
+
 /* RemoteTransmitterBase */
 
 void RemoteTransmitterBase::send_(uint32_t send_times, uint32_t send_wait) {

esphome/components/remote_base/remote_base.h

@@ -36,6 +36,11 @@ class RemoteTransmitData {
   /// @param len Length of the buffer in bytes
   /// @param count Number of values (for reserve optimization)
   void set_data_from_packed_sint32(const uint8_t *data, size_t len, size_t count);
+  /// Set data from base85-encoded int32 values
+  /// Decodes directly into internal buffer (zero heap allocations)
+  /// @param base85 Base85-encoded string (5 chars per int32 value)
+  /// @return true if successful, false if decode failed or invalid size
+  bool set_data_from_base85(const std::string &base85);
   void reset() {
     this->data_.clear();
     this->carrier_frequency_ = 0;