spdif_encoder.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
 
#if defined(USE_ESP32) && defined(USE_I2S_AUDIO_SPDIF_MODE)
 
#include <array>
#include <cstdint>
#include <memory>
#include <freertos/FreeRTOS.h>
#include "esp_err.h"
#include "esphome/core/helpers.h"
 
namespace esphome::i2s_audio {
 
// A SPDIF sample is 64-bits
static constexpr uint8_t SPDIF_BITS_PER_SAMPLE = 64;
// Number of samples in a SPDIF block
static constexpr uint16_t SPDIF_BLOCK_SAMPLES = 192;
// To emulate bi-phase mark code (BMC) (aka differential Manchester encoding) we send twice
//  as many bits per sample so that we can generate the transitions this encoding requires.
static constexpr uint8_t EMULATED_BMC_BITS_PER_SAMPLE = SPDIF_BITS_PER_SAMPLE * 2;
static constexpr uint16_t SPDIF_BLOCK_SIZE_BYTES = SPDIF_BLOCK_SAMPLES * (EMULATED_BMC_BITS_PER_SAMPLE / 8);
static constexpr uint32_t SPDIF_BLOCK_SIZE_U32 = SPDIF_BLOCK_SIZE_BYTES / sizeof(uint32_t);  // 3072 bytes / 4 = 768
// I2S frame count for one SPDIF block (for new driver where frame = 8 bytes for 32-bit stereo)
static constexpr uint32_t SPDIF_BLOCK_I2S_FRAMES = SPDIF_BLOCK_SIZE_BYTES / 8;  // 3072 / 8 = 384 frames
 
using SPDIFBlockCallback = esp_err_t (*)(void *user_ctx, uint32_t *data, size_t size, TickType_t ticks_to_wait);
 
class SPDIFEncoder {
 public:
  bool setup();
 
  void set_write_callback(SPDIFBlockCallback callback, void *user_ctx) {
    this->write_callback_ = callback;
    this->write_callback_ctx_ = user_ctx;
  }
 
  void set_preload_callback(SPDIFBlockCallback callback, void *user_ctx) {
    this->preload_callback_ = callback;
    this->preload_callback_ctx_ = user_ctx;
  }
 
  void set_preload_mode(bool preload) { this->preload_mode_ = preload; }
 
  bool is_preload_mode() const { return this->preload_mode_; }
 
  void set_bytes_per_sample(uint8_t bytes_per_sample);
 
  uint8_t get_bytes_per_sample() const { return this->bytes_per_sample_; }
 
  esp_err_t write(const uint8_t *src, size_t size, TickType_t ticks_to_wait, uint32_t *blocks_sent = nullptr,
                  size_t *bytes_consumed = nullptr);
 
  esp_err_t flush_with_silence(TickType_t ticks_to_wait);
 
  void reset();
 
  void set_sample_rate(uint32_t sample_rate);
 
  uint32_t get_sample_rate() const { return this->sample_rate_; }
 
 protected:
  template<uint8_t Bps> void encode_silence_frame_();
 
  template<uint8_t Bps>
  HOT esp_err_t write_typed_(const uint8_t *src, size_t size, TickType_t ticks_to_wait, uint32_t *blocks_sent,
                             size_t *bytes_consumed);
 
  template<uint8_t Bps> esp_err_t flush_with_silence_typed_(TickType_t ticks_to_wait);
 
  esp_err_t send_block_(TickType_t ticks_to_wait);
 
  void build_channel_status_();
 
  // Member ordering optimized to minimize padding (largest alignment first)
 
  // 4-byte aligned members (pointers and uint32_t)
  SPDIFBlockCallback write_callback_{nullptr};
  SPDIFBlockCallback preload_callback_{nullptr};
  void *write_callback_ctx_{nullptr};
  void *preload_callback_ctx_{nullptr};
  std::unique_ptr<uint32_t[]> spdif_block_buf_;  // Working buffer for SPDIF block (heap allocated)
  uint32_t *spdif_block_ptr_{nullptr};           // Current position in block buffer
  uint32_t sample_rate_{48000};                  // Sample rate for Channel Status Block encoding
 
  // 1-byte aligned members (grouped together to avoid internal padding)
  uint8_t bytes_per_sample_{2};  // Input PCM width: 2/3/4 (16/24/32-bit). 32-bit truncates to 24-bit on the wire.
  uint8_t frame_in_block_{0};    // 0-191, tracks stereo frame position within block
  bool preload_mode_{false};     // Whether to use preload callback vs write callback
  // True when spdif_block_buf_ currently holds a complete full-silence block valid for the active
  // channel status. A full silence block is deterministic for a given sample rate and word length,
  // so when this is set flush_with_silence() can re-send the buffer verbatim instead of re-encoding.
  bool block_buf_is_silence_block_{false};
 
  // Channel Status Block (192 bits = 24 bytes, transmitted over 192 frames)
  // Placed last since std::array<uint8_t> has 1-byte alignment
  std::array<uint8_t, 24> channel_status_{};
};
 
}  // namespace esphome::i2s_audio
 
#endif  // USE_I2S_AUDIO_SPDIF_MODE