sendspin_image.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
 
#if defined(USE_ESP32) && defined(USE_SENDSPIN_ARTWORK)
 
#include "esphome/components/image/image.h"
#include "esphome/components/runtime_image/runtime_image.h"
#include "esphome/components/sendspin/sendspin_hub.h"
 
#include "esphome/core/helpers.h"
 
#include <sendspin/artwork_role.h>
 
#include <array>
#include <cstdint>
 
namespace esphome::sendspin_ {
 
class ArtworkDecodeSink : public runtime_image::RuntimeImage {
 public:
  using runtime_image::RuntimeImage::RuntimeImage;
 
  bool decoded_into(const uint8_t *buffer) const { return this->buffer_ == buffer; }
};
 
class ArtworkImageView : public image::Image {
 public:
  using image::Image::Image;
 
  void set_frame(const uint8_t *data, int width, int height) {
    this->data_start_ = data;
    this->width_ = width;
    this->height_ = height;
#ifdef USE_LVGL
    // Keep the descriptor LVGL is handed in step with the frame. This does not redraw anything:
    // only setting a widget's source invalidates it.
    this->get_lv_image_dsc();
#endif
  }
 
  void set_showing_artwork(bool showing_artwork) { this->showing_artwork_ = showing_artwork; }
 
  void set_placeholder(image::Image *placeholder) { this->placeholder_ = placeholder; }
 
  void draw(int x, int y, display::Display *display, Color color_on, Color color_off) override {
    if (!this->showing_artwork_) {
      // Nothing worth showing yet: the placeholder if there is one, otherwise leave the area be
      // rather than paint a blank frame over it.
      if (this->placeholder_ != nullptr) {
        this->placeholder_->draw(x, y, display, color_on, color_off);
      }
      return;
    }
    image::Image::draw(x, y, display, color_on, color_off);
  }
 
 protected:
  image::Image *placeholder_{nullptr};
  bool showing_artwork_{false};
};
 
class SendspinImageSlot : public SendspinChild {
 public:
  SendspinImageSlot(uint8_t slot, ArtworkImageView *current_image, int width, int height,
                    runtime_image::ImageFormat format, image::ImageType type, image::Transparency transparency,
                    bool is_big_endian)
      : decode_sink_(format, type, transparency, nullptr, is_big_endian, width, height),
        current_image_(current_image),
        width_(width),
        height_(height),
        slot_(slot) {}
 
  void setup() override;
  void dump_config() override;
 
  template<typename F> void add_on_image_display_callback(F &&callback) {
    this->image_display_callback_.add(std::forward<F>(callback));
  }
  template<typename F> void add_on_image_clear_callback(F &&callback) {
    this->image_clear_callback_.add(std::forward<F>(callback));
  }
  template<typename F> void add_on_image_error_callback(F &&callback) {
    this->image_error_callback_.add(std::forward<F>(callback));
  }
 
  void set_transition_image(ArtworkImageView *transition_image) { this->transition_image_ = transition_image; }
 
  void transition_finished();
 
 protected:
  void on_decode_(const uint8_t *data, size_t length);
  bool decode_frame_(const uint8_t *data, size_t length, const uint8_t *target);
  void on_display_(uint32_t lateness_ms);
  void on_clear_();
  void finish_transition_();
  void apply_frames_(bool transition_is_artwork);
  void report_error_();
 
  ArtworkDecodeSink decode_sink_;
 
  // The two frame buffers, allocated in setup() and never freed. Their contents are written on the
  // decode thread and read by whatever draws the views, so only their roles are swapped, never the
  // pointers themselves.
  std::array<uint8_t *, 2> buffers_{};
 
  // pending_mutex_ guards the two fields below, the only state shared across threads. Everything
  // after them is touched on the main loop only.
  Mutex pending_mutex_;
  // Index into buffers_ of the frame the current image shows. buffers_[current_index_ ^ 1] holds
  // the outgoing frame and is the next decode target. Written on the main loop, read on the
  // decode thread.
  uint8_t current_index_{0};
  // Set on the decode thread once a frame is waiting in buffers_[current_index_ ^ 1].
  bool frame_pending_{false};
 
  // True once artwork has been displayed, until the next clear; decides whether the outgoing frame
  // is real artwork or the black the buffers start as. Main loop only.
  bool showing_artwork_{false};
  // True while a displayed frame awaits transition_finished(); gates duplicate or stray calls
  // so exactly one ack reaches the library per delivery. Main loop only.
  bool transition_pending_{false};
 
  ArtworkImageView *current_image_;
  ArtworkImageView *transition_image_{nullptr};
  int width_;
  int height_;
  uint8_t slot_;
 
  LazyCallbackManager<void(uint32_t)> image_display_callback_{};
  LazyCallbackManager<void()> image_clear_callback_{};
  LazyCallbackManager<void()> image_error_callback_{};
};
 
}  // namespace esphome::sendspin_
 
#endif