mirror of
https://github.com/sle118/squeezelite-esp32.git
synced 2025-12-07 12:07:09 +03:00
182 lines
8.1 KiB
C++
182 lines
8.1 KiB
C++
#include "SPDIFAudioSink.h"
|
||
|
||
#include "driver/i2s.h"
|
||
|
||
// See http://www.hardwarebook.info/S/PDIF for more info on this protocol
|
||
// Conversion table to biphase code mark (LSB first, ending in 1)
|
||
static const uint16_t bmc_convert[256] = {
|
||
0x3333, 0xb333, 0xd333, 0x5333, 0xcb33, 0x4b33, 0x2b33, 0xab33,
|
||
0xcd33, 0x4d33, 0x2d33, 0xad33, 0x3533, 0xb533, 0xd533, 0x5533,
|
||
0xccb3, 0x4cb3, 0x2cb3, 0xacb3, 0x34b3, 0xb4b3, 0xd4b3, 0x54b3,
|
||
0x32b3, 0xb2b3, 0xd2b3, 0x52b3, 0xcab3, 0x4ab3, 0x2ab3, 0xaab3,
|
||
0xccd3, 0x4cd3, 0x2cd3, 0xacd3, 0x34d3, 0xb4d3, 0xd4d3, 0x54d3,
|
||
0x32d3, 0xb2d3, 0xd2d3, 0x52d3, 0xcad3, 0x4ad3, 0x2ad3, 0xaad3,
|
||
0x3353, 0xb353, 0xd353, 0x5353, 0xcb53, 0x4b53, 0x2b53, 0xab53,
|
||
0xcd53, 0x4d53, 0x2d53, 0xad53, 0x3553, 0xb553, 0xd553, 0x5553,
|
||
0xcccb, 0x4ccb, 0x2ccb, 0xaccb, 0x34cb, 0xb4cb, 0xd4cb, 0x54cb,
|
||
0x32cb, 0xb2cb, 0xd2cb, 0x52cb, 0xcacb, 0x4acb, 0x2acb, 0xaacb,
|
||
0x334b, 0xb34b, 0xd34b, 0x534b, 0xcb4b, 0x4b4b, 0x2b4b, 0xab4b,
|
||
0xcd4b, 0x4d4b, 0x2d4b, 0xad4b, 0x354b, 0xb54b, 0xd54b, 0x554b,
|
||
0x332b, 0xb32b, 0xd32b, 0x532b, 0xcb2b, 0x4b2b, 0x2b2b, 0xab2b,
|
||
0xcd2b, 0x4d2b, 0x2d2b, 0xad2b, 0x352b, 0xb52b, 0xd52b, 0x552b,
|
||
0xccab, 0x4cab, 0x2cab, 0xacab, 0x34ab, 0xb4ab, 0xd4ab, 0x54ab,
|
||
0x32ab, 0xb2ab, 0xd2ab, 0x52ab, 0xcaab, 0x4aab, 0x2aab, 0xaaab,
|
||
0xcccd, 0x4ccd, 0x2ccd, 0xaccd, 0x34cd, 0xb4cd, 0xd4cd, 0x54cd,
|
||
0x32cd, 0xb2cd, 0xd2cd, 0x52cd, 0xcacd, 0x4acd, 0x2acd, 0xaacd,
|
||
0x334d, 0xb34d, 0xd34d, 0x534d, 0xcb4d, 0x4b4d, 0x2b4d, 0xab4d,
|
||
0xcd4d, 0x4d4d, 0x2d4d, 0xad4d, 0x354d, 0xb54d, 0xd54d, 0x554d,
|
||
0x332d, 0xb32d, 0xd32d, 0x532d, 0xcb2d, 0x4b2d, 0x2b2d, 0xab2d,
|
||
0xcd2d, 0x4d2d, 0x2d2d, 0xad2d, 0x352d, 0xb52d, 0xd52d, 0x552d,
|
||
0xccad, 0x4cad, 0x2cad, 0xacad, 0x34ad, 0xb4ad, 0xd4ad, 0x54ad,
|
||
0x32ad, 0xb2ad, 0xd2ad, 0x52ad, 0xcaad, 0x4aad, 0x2aad, 0xaaad,
|
||
0x3335, 0xb335, 0xd335, 0x5335, 0xcb35, 0x4b35, 0x2b35, 0xab35,
|
||
0xcd35, 0x4d35, 0x2d35, 0xad35, 0x3535, 0xb535, 0xd535, 0x5535,
|
||
0xccb5, 0x4cb5, 0x2cb5, 0xacb5, 0x34b5, 0xb4b5, 0xd4b5, 0x54b5,
|
||
0x32b5, 0xb2b5, 0xd2b5, 0x52b5, 0xcab5, 0x4ab5, 0x2ab5, 0xaab5,
|
||
0xccd5, 0x4cd5, 0x2cd5, 0xacd5, 0x34d5, 0xb4d5, 0xd4d5, 0x54d5,
|
||
0x32d5, 0xb2d5, 0xd2d5, 0x52d5, 0xcad5, 0x4ad5, 0x2ad5, 0xaad5,
|
||
0x3355, 0xb355, 0xd355, 0x5355, 0xcb55, 0x4b55, 0x2b55, 0xab55,
|
||
0xcd55, 0x4d55, 0x2d55, 0xad55, 0x3555, 0xb555, 0xd555, 0x5555,
|
||
};
|
||
|
||
#define I2S_BUG_MAGIC (26 * 1000 * 1000) // magic number for avoiding I2S bug
|
||
#define BITS_PER_SUBFRAME 64
|
||
#define FRAMES_PER_BLOCK 192
|
||
#define SPDIF_BUF_SIZE (BITS_PER_SUBFRAME/8 * 2 * FRAMES_PER_BLOCK)
|
||
#define SPDIF_BUF_ARRAY_SIZE (SPDIF_BUF_SIZE / sizeof(uint32_t))
|
||
|
||
#define BMC_B 0x33173333 // block start
|
||
#define BMC_M 0x331d3333 // left ch
|
||
#define BMC_W 0x331b3333 // right ch
|
||
#define BMC_MW_DIF (BMC_M ^ BMC_W)
|
||
|
||
static uint32_t spdif_buf[SPDIF_BUF_ARRAY_SIZE];
|
||
static uint32_t *spdif_ptr;
|
||
|
||
static void spdif_buf_init(void)
|
||
{
|
||
// first bllock has W preamble
|
||
spdif_buf[0] = BMC_B;
|
||
|
||
// all other blocks are alternating M, then W preamble
|
||
uint32_t bmc_mw = BMC_M;
|
||
for (int i = 2; i < SPDIF_BUF_ARRAY_SIZE; i += 2)
|
||
{
|
||
spdif_buf[i] = bmc_mw ^= BMC_MW_DIF;
|
||
}
|
||
}
|
||
|
||
SPDIFAudioSink::SPDIFAudioSink(uint8_t spdifPin)
|
||
{
|
||
// initialize S/PDIF buffer
|
||
spdif_buf_init();
|
||
spdif_ptr = spdif_buf;
|
||
this->spdifPin = spdifPin;
|
||
this->setParams(44100, 16, 2);
|
||
startI2sFeed(SPDIF_BUF_SIZE * 16);
|
||
}
|
||
|
||
bool SPDIFAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t bitDepth) {
|
||
if (bitDepth != 16 || channelCount != 2) // TODO support mono playback and different bit widths
|
||
return false;
|
||
int sample_rate = (int)sampleRate * 2;
|
||
int bclk = sample_rate * 64 * 2;
|
||
int mclk = (I2S_BUG_MAGIC / bclk) * bclk;
|
||
|
||
i2s_config_t i2s_config = {
|
||
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
|
||
.sample_rate = (uint32_t)sample_rate,
|
||
.bits_per_sample = (i2s_bits_per_sample_t)(bitDepth * 2),
|
||
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
|
||
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
|
||
.intr_alloc_flags = 0,
|
||
.dma_buf_count = 8,
|
||
.dma_buf_len = 512,
|
||
.use_apll = true,
|
||
.tx_desc_auto_clear = true,
|
||
.fixed_mclk = mclk, // avoiding I2S bug
|
||
};
|
||
i2s_pin_config_t pin_config = {
|
||
.bck_io_num = -1,
|
||
.ws_io_num = -1,
|
||
.data_out_num = spdifPin,
|
||
.data_in_num = -1,
|
||
};
|
||
i2s_driver_uninstall((i2s_port_t)0);
|
||
int err = i2s_driver_install((i2s_port_t)0, &i2s_config, 0, nullptr);
|
||
i2s_set_pin((i2s_port_t)0, &pin_config);
|
||
return !err;
|
||
}
|
||
|
||
SPDIFAudioSink::~SPDIFAudioSink() {
|
||
i2s_driver_uninstall((i2s_port_t)0);
|
||
}
|
||
|
||
int num_frames = 0;
|
||
|
||
void SPDIFAudioSink::feedPCMFrames(const uint8_t *buffer, size_t bytes)
|
||
{
|
||
for (int i = 0; i < bytes; i += 2)
|
||
{
|
||
/**
|
||
* What is this, and why does it work?
|
||
*
|
||
* Rather than assemble all S/PDIF frames from scratch we want to do the
|
||
* minimum amount of work possible. To that extent, we fix the final four
|
||
* bits (VUCP) to be all-zero prior to BMC encoding (= valid, no subcode
|
||
* or channel-status bits set, even parity), and zero the lowest 8 sample
|
||
* bits (prior to BMC encoding). This is all done in spdif_buf_init(),
|
||
* aligning at word boundaries and setting alternating preambles as well
|
||
* as encoding 8 bits of zeros as 0x33, leaving the final bit high.
|
||
*
|
||
* We must therefore BMC encode our 16 bit PCM data in such a way that:
|
||
* - the first (least significant) bit is 0 (to fit with 0x33 zeros)
|
||
* - the final bit is 1 (so as to fit with the following 0x33 VUCP bits)
|
||
* - the result has even parity
|
||
*
|
||
* As biphase mark code retains parity (0 encodes as two 1s or two 0s),
|
||
* this is evidently not possible without loss of data, as the input PCM
|
||
* data isn't already even parity. We can use the first (least significant)
|
||
* bit as parity bit to achieve our desired encoding.
|
||
*
|
||
* The bmc_convert table converts the lower and upper 8 bit of our PCM
|
||
* frames into 16 bit biphase mark code patterns with the first two bits
|
||
* encoding the LSB and the final bit always high. We combine both 16bit
|
||
* patterns into a 32 bit encoding of our original input data by shifting
|
||
* the first (lower) 16 bit into position, then sign-extending the second
|
||
* (higher) 16bit pattern. If that pattern started with a 1, the resulting
|
||
* 32 bit pattern will now contain 1s in the first 16 bits.
|
||
*
|
||
* Keep in mind that the shifted value in the first (lower) 16 bits always
|
||
* ends in a 1 bit, so the entire pattern must be flipped in case the
|
||
* second (higher) 16 bit pattern starts with a 1 bit. XORing the sign-
|
||
* extended component to the first one achieves exactly that.
|
||
*
|
||
* Finally, we zero out the very first bit of the resulting value. This
|
||
* may change the lowest bit of our encoded value, but ensures that our
|
||
* newly encoded bits form a valid BMC pattern with the already zeroed out
|
||
* lower 8 bits in the pattern set up in spdif_buf_init().
|
||
*
|
||
* Further, this also happens to ensure even parity:
|
||
* All entries in the BMC table end in a 1, so an all-zero pattern would
|
||
* end (after encoding an even number of bits) in two 0 bits. Setting any
|
||
* bit will cause the BMC-encoded pattern to flip its first (lowest) bit,
|
||
* meaning we can use that bit to infer parity. Setting it to zero flips
|
||
* the first (lowest) bit such that we always have even parity.
|
||
*
|
||
* I did not come up with this, all credit goes to
|
||
* github.com/amedes/esp_a2dp_sink_spdif
|
||
*/
|
||
uint32_t lo = ((uint32_t)(bmc_convert[buffer[i]]) << 16);
|
||
uint32_t hi = (uint32_t)((int16_t)bmc_convert[buffer[i+1]]);
|
||
|
||
*(spdif_ptr + 1) = ((lo ^ hi) << 1) >> 1;
|
||
|
||
spdif_ptr += 2; // advance to next audio data
|
||
|
||
if (spdif_ptr >= &spdif_buf[SPDIF_BUF_ARRAY_SIZE]) {
|
||
feedPCMFramesInternal(spdif_buf, sizeof(spdif_buf));
|
||
spdif_ptr = spdif_buf;
|
||
}
|
||
}
|
||
} |