image_decoder.h

Go to the documentation of this file.

#pragma once
#include "esphome/core/defines.h"
#include "esphome/core/color.h"

namespace esphome {
namespace online_image {

class OnlineImage;

class ImageDecoder {
 public:
  ImageDecoder(OnlineImage *image) : image_(image) {}
  virtual ~ImageDecoder() = default;

  virtual void prepare(uint32_t download_size) { this->download_size_ = download_size; }

  virtual int decode(uint8_t *buffer, size_t size);

  void set_size(int width, int height);

  void draw(int x, int y, int w, int h, const Color &color);

  bool is_finished() const { return this->decoded_bytes_ == this->download_size_; }

 protected:
  OnlineImage *image_;
  // Initializing to 1, to ensure it is different than initial "decoded_bytes_".
  // Will be overwritten anyway once the download size is known.
  uint32_t download_size_ = 1;
  uint32_t decoded_bytes_ = 0;
  double x_scale_ = 1.0;
  double y_scale_ = 1.0;
};

class DownloadBuffer {
 public:
  DownloadBuffer(size_t size) : size_(size) {
    this->buffer_ = this->allocator_.allocate(size);
    this->reset();
  }

  virtual ~DownloadBuffer() { this->allocator_.deallocate(this->buffer_, this->size_); }

  uint8_t *data(size_t offset = 0);

  uint8_t *append() { return this->data(this->unread_); }

  size_t unread() const { return this->unread_; }
  size_t size() const { return this->size_; }
  size_t free_capacity() const { return this->size_ - this->unread_; }

  size_t read(size_t len);
  size_t write(size_t len) {
    this->unread_ += len;
    return this->unread_;
  }

  void reset() { this->unread_ = 0; }

 protected:
  ExternalRAMAllocator<uint8_t> allocator_;
  uint8_t *buffer_;
  size_t size_;
  size_t unread_;
};

}  // namespace online_image
}  // namespace esphome