#include "k10_audio_codec.h"
|
|
#include <esp_log.h>
|
#include <driver/i2c_master.h>
|
#include <driver/i2s_tdm.h>
|
#include <cmath>
|
|
static const char TAG[] = "K10AudioCodec";
|
|
K10AudioCodec::K10AudioCodec(void* i2c_master_handle, int input_sample_rate, int output_sample_rate,
|
gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din,
|
gpio_num_t pa_pin, uint8_t es8311_addr, uint8_t es7210_addr, bool input_reference) {
|
duplex_ = true; // 是否双工
|
input_reference_ = input_reference; // 是否使用参考输入，实现回声消除
|
input_channels_ = input_reference_ ? 2 : 1; // 输入通道数
|
input_sample_rate_ = input_sample_rate;
|
output_sample_rate_ = output_sample_rate;
|
|
CreateDuplexChannels(mclk, bclk, ws, dout, din);
|
|
// Do initialize of related interface: data_if, ctrl_if and gpio_if
|
audio_codec_i2s_cfg_t i2s_cfg = {
|
.port = I2S_NUM_0,
|
.rx_handle = rx_handle_,
|
.tx_handle = tx_handle_,
|
};
|
data_if_ = audio_codec_new_i2s_data(&i2s_cfg);
|
assert(data_if_ != NULL);
|
|
audio_codec_i2c_cfg_t i2c_cfg = {
|
.port = I2C_NUM_1,
|
.addr = es7210_addr,
|
.bus_handle = i2c_master_handle,
|
};
|
const audio_codec_ctrl_if_t *in_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
|
assert(in_ctrl_if_ != NULL);
|
|
es7243e_codec_cfg_t es7243e_cfg = {
|
.ctrl_if = in_ctrl_if_,
|
};
|
const audio_codec_if_t *in_codec_if_ = es7243e_codec_new(&es7243e_cfg);
|
assert(in_codec_if_ != NULL);
|
|
esp_codec_dev_cfg_t codec_es7243e_dev_cfg = {
|
.dev_type = ESP_CODEC_DEV_TYPE_IN,
|
.codec_if = in_codec_if_,
|
.data_if = data_if_,
|
};
|
input_dev_ = esp_codec_dev_new(&codec_es7243e_dev_cfg);
|
|
assert(input_dev_ != NULL);
|
|
ESP_LOGI(TAG, "DF-K10 AudioDevice initialized");
|
}
|
|
K10AudioCodec::~K10AudioCodec() {
|
ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
|
esp_codec_dev_delete(output_dev_);
|
ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
|
esp_codec_dev_delete(input_dev_);
|
|
audio_codec_delete_codec_if(in_codec_if_);
|
audio_codec_delete_ctrl_if(in_ctrl_if_);
|
audio_codec_delete_codec_if(out_codec_if_);
|
audio_codec_delete_ctrl_if(out_ctrl_if_);
|
audio_codec_delete_gpio_if(gpio_if_);
|
audio_codec_delete_data_if(data_if_);
|
}
|
|
void K10AudioCodec::CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din) {
|
assert(input_sample_rate_ == output_sample_rate_);
|
|
i2s_chan_config_t chan_cfg = {
|
.id = I2S_NUM_0,
|
.role = I2S_ROLE_MASTER,
|
.dma_desc_num = AUDIO_CODEC_DMA_DESC_NUM,
|
.dma_frame_num = AUDIO_CODEC_DMA_FRAME_NUM,
|
.auto_clear_after_cb = true,
|
.auto_clear_before_cb = false,
|
.intr_priority = 0,
|
};
|
ESP_ERROR_CHECK(i2s_new_channel(&chan_cfg, &tx_handle_, &rx_handle_));
|
|
i2s_std_config_t std_cfg = {
|
.clk_cfg = {
|
.sample_rate_hz = (uint32_t)output_sample_rate_,
|
.clk_src = I2S_CLK_SRC_DEFAULT,
|
.ext_clk_freq_hz = 0,
|
.mclk_multiple = I2S_MCLK_MULTIPLE_256
|
},
|
.slot_cfg = {
|
.data_bit_width = I2S_DATA_BIT_WIDTH_16BIT,
|
.slot_bit_width = I2S_SLOT_BIT_WIDTH_AUTO,
|
.slot_mode = I2S_SLOT_MODE_MONO,
|
.slot_mask = I2S_STD_SLOT_BOTH,
|
.ws_width = I2S_DATA_BIT_WIDTH_16BIT,
|
.ws_pol = false,
|
.bit_shift = true,
|
.left_align = true,
|
.big_endian = false,
|
.bit_order_lsb = false
|
},
|
.gpio_cfg = {
|
// .mclk = mclk,
|
.bclk = bclk,
|
.ws = ws,
|
.dout = dout,
|
.din = I2S_GPIO_UNUSED,
|
.invert_flags = {
|
.mclk_inv = false,
|
.bclk_inv = false,
|
.ws_inv = false
|
}
|
}
|
};
|
|
i2s_tdm_config_t tdm_cfg = {
|
.clk_cfg = {
|
.sample_rate_hz = (uint32_t)input_sample_rate_,
|
.clk_src = I2S_CLK_SRC_DEFAULT,
|
.ext_clk_freq_hz = 0,
|
.mclk_multiple = I2S_MCLK_MULTIPLE_256,
|
.bclk_div = 8,
|
},
|
.slot_cfg = {
|
.data_bit_width = I2S_DATA_BIT_WIDTH_16BIT,
|
.slot_bit_width = I2S_SLOT_BIT_WIDTH_AUTO,
|
.slot_mode = I2S_SLOT_MODE_STEREO,
|
.slot_mask = i2s_tdm_slot_mask_t(I2S_TDM_SLOT0 | I2S_TDM_SLOT1 | I2S_TDM_SLOT2 | I2S_TDM_SLOT3),
|
.ws_width = I2S_TDM_AUTO_WS_WIDTH,
|
.ws_pol = false,
|
.bit_shift = true,
|
.left_align = false,
|
.big_endian = false,
|
.bit_order_lsb = false,
|
.skip_mask = false,
|
.total_slot = I2S_TDM_AUTO_SLOT_NUM
|
},
|
.gpio_cfg = {
|
.mclk = mclk,
|
.bclk = bclk,
|
.ws = ws,
|
.dout = I2S_GPIO_UNUSED,
|
.din = din,
|
.invert_flags = {
|
.mclk_inv = false,
|
.bclk_inv = false,
|
.ws_inv = false
|
}
|
}
|
};
|
|
ESP_ERROR_CHECK(i2s_channel_init_std_mode(tx_handle_, &std_cfg));
|
ESP_ERROR_CHECK(i2s_channel_init_tdm_mode(rx_handle_, &tdm_cfg));
|
ESP_ERROR_CHECK(i2s_channel_enable(tx_handle_));
|
ESP_ERROR_CHECK(i2s_channel_enable(rx_handle_));
|
ESP_LOGI(TAG, "Duplex channels created");
|
}
|
|
void K10AudioCodec::SetOutputVolume(int volume) {
|
AudioCodec::SetOutputVolume(volume);
|
}
|
|
void K10AudioCodec::EnableInput(bool enable) {
|
if (enable == input_enabled_) {
|
return;
|
}
|
if (enable) {
|
esp_codec_dev_sample_info_t fs = {
|
.bits_per_sample = 16,
|
.channel = 4,
|
.channel_mask = ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0),
|
.sample_rate = (uint32_t)output_sample_rate_,
|
.mclk_multiple = 0,
|
};
|
if (input_reference_) {
|
fs.channel_mask |= ESP_CODEC_DEV_MAKE_CHANNEL_MASK(1);
|
}
|
ESP_ERROR_CHECK(esp_codec_dev_open(input_dev_, &fs));
|
ESP_ERROR_CHECK(esp_codec_dev_set_in_gain(input_dev_, 37.5)); //麦克风增益解决收音太小的问题
|
} else {
|
ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
|
}
|
AudioCodec::EnableInput(enable);
|
}
|
|
void K10AudioCodec::EnableOutput(bool enable) {
|
if (enable == output_enabled_) {
|
return;
|
}
|
AudioCodec::SetOutputVolume(output_volume_);
|
AudioCodec::EnableOutput(enable);
|
}
|
|
int K10AudioCodec::Read(int16_t* dest, int samples) {
|
if (input_enabled_) {
|
ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t)));
|
}
|
return samples;
|
}
|
|
int K10AudioCodec::Write(const int16_t* data, int samples) {
|
if (output_enabled_) {
|
std::vector<int32_t> buffer(samples * 2); // Allocate buffer for 2x samples
|
|
// Apply volume adjustment (same as before)
|
int32_t volume_factor = pow(double(output_volume_) / 100.0, 2) * 65536;
|
for (int i = 0; i < samples; i++) {
|
int64_t temp = int64_t(data[i]) * volume_factor;
|
if (temp > INT32_MAX) {
|
buffer[i * 2] = INT32_MAX;
|
} else if (temp < INT32_MIN) {
|
buffer[i * 2] = INT32_MIN;
|
} else {
|
buffer[i * 2] = static_cast<int32_t>(temp);
|
}
|
|
// Repeat each sample for slow playback (assuming mono audio)
|
buffer[i * 2 + 1] = buffer[i * 2];
|
}
|
|
size_t bytes_written;
|
ESP_ERROR_CHECK(i2s_channel_write(tx_handle_, buffer.data(), samples * 2 * sizeof(int32_t), &bytes_written, portMAX_DELAY));
|
return bytes_written / sizeof(int32_t);
|
}
|
return samples;
|
}
|
