mirror of
https://github.com/sweidac/kidsbox.git
synced 2025-07-27 19:31:54 +02:00
214 lines
7.7 KiB
C
214 lines
7.7 KiB
C
/*
|
|
* ESPRESSIF MIT License
|
|
*
|
|
* Copyright (c) 2019 <ESPRESSIF SYSTEMS (SHANGHAI) CO., LTD>
|
|
*
|
|
* Permission is hereby granted for use on all ESPRESSIF SYSTEMS products, in which case,
|
|
* it is free of charge, to any person obtaining a copy of this software and associated
|
|
* documentation files (the "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
|
|
* to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all copies or
|
|
* substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/timers.h"
|
|
#include <freertos/semphr.h>
|
|
|
|
#include "esp_log.h"
|
|
#include "recorder_engine.h"
|
|
#include "esp_audio.h"
|
|
#include "audio_element.h"
|
|
#include "audio_pipeline.h"
|
|
#include "audio_mem.h"
|
|
#include "board.h"
|
|
#include "audio_common.h"
|
|
#include "audio_hal.h"
|
|
#include "filter_resample.h"
|
|
#include "fatfs_stream.h"
|
|
#include "raw_stream.h"
|
|
#include "i2s_stream.h"
|
|
#include "wav_decoder.h"
|
|
#include "wav_encoder.h"
|
|
#include "mp3_decoder.h"
|
|
#include "aac_decoder.h"
|
|
#include "http_stream.h"
|
|
|
|
static char *TAG = "AUDIO_SETUP";
|
|
static audio_element_handle_t raw_read;
|
|
|
|
static int _http_stream_event_handle(http_stream_event_msg_t *msg)
|
|
{
|
|
if (msg->event_id == HTTP_STREAM_RESOLVE_ALL_TRACKS) {
|
|
return ESP_OK;
|
|
}
|
|
|
|
if (msg->event_id == HTTP_STREAM_FINISH_TRACK) {
|
|
return http_stream_next_track(msg->el);
|
|
}
|
|
if (msg->event_id == HTTP_STREAM_FINISH_PLAYLIST) {
|
|
return http_stream_restart(msg->el);
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
void *setup_player(void *cb, void *ctx)
|
|
{
|
|
esp_audio_cfg_t cfg = DEFAULT_ESP_AUDIO_CONFIG();
|
|
audio_board_handle_t board_handle = audio_board_init();
|
|
audio_hal_ctrl_codec(board_handle->audio_hal, AUDIO_HAL_CODEC_MODE_BOTH, AUDIO_HAL_CTRL_START);
|
|
|
|
cfg.vol_handle = board_handle->audio_hal;
|
|
cfg.vol_set = (audio_volume_set)audio_hal_set_volume;
|
|
cfg.vol_get = (audio_volume_get)audio_hal_get_volume;
|
|
cfg.resample_rate = 48000;
|
|
cfg.prefer_type = ESP_AUDIO_PREFER_MEM;
|
|
cfg.cb_func = cb;
|
|
cfg.cb_ctx = ctx;
|
|
esp_audio_handle_t handle = esp_audio_create(&cfg);
|
|
|
|
// Create readers and add to esp_audio
|
|
fatfs_stream_cfg_t fs_reader = FATFS_STREAM_CFG_DEFAULT();
|
|
fs_reader.type = AUDIO_STREAM_READER;
|
|
|
|
esp_audio_input_stream_add(handle, fatfs_stream_init(&fs_reader));
|
|
http_stream_cfg_t http_cfg = HTTP_STREAM_CFG_DEFAULT();
|
|
http_cfg.event_handle = _http_stream_event_handle;
|
|
http_cfg.type = AUDIO_STREAM_READER;
|
|
http_cfg.enable_playlist_parser = true;
|
|
audio_element_handle_t http_stream_reader = http_stream_init(&http_cfg);
|
|
esp_audio_input_stream_add(handle, http_stream_reader);
|
|
http_stream_reader = http_stream_init(&http_cfg);
|
|
esp_audio_input_stream_add(handle, http_stream_reader);
|
|
|
|
// Add decoders and encoders to esp_audio
|
|
wav_decoder_cfg_t wav_dec_cfg = DEFAULT_WAV_DECODER_CONFIG();
|
|
mp3_decoder_cfg_t mp3_dec_cfg = DEFAULT_MP3_DECODER_CONFIG();
|
|
mp3_dec_cfg.task_core = 1;
|
|
aac_decoder_cfg_t aac_cfg = DEFAULT_AAC_DECODER_CONFIG();
|
|
aac_cfg.task_core = 1;
|
|
esp_audio_codec_lib_add(handle, AUDIO_CODEC_TYPE_DECODER, aac_decoder_init(&aac_cfg));
|
|
esp_audio_codec_lib_add(handle, AUDIO_CODEC_TYPE_DECODER, wav_decoder_init(&wav_dec_cfg));
|
|
esp_audio_codec_lib_add(handle, AUDIO_CODEC_TYPE_DECODER, mp3_decoder_init(&mp3_dec_cfg));
|
|
|
|
audio_element_handle_t m4a_dec_cfg = aac_decoder_init(&aac_cfg);
|
|
audio_element_set_tag(m4a_dec_cfg, "m4a");
|
|
esp_audio_codec_lib_add(handle, AUDIO_CODEC_TYPE_DECODER, m4a_dec_cfg);
|
|
|
|
audio_element_handle_t ts_dec_cfg = aac_decoder_init(&aac_cfg);
|
|
audio_element_set_tag(ts_dec_cfg, "ts");
|
|
esp_audio_codec_lib_add(handle, AUDIO_CODEC_TYPE_DECODER, ts_dec_cfg);
|
|
|
|
// Create writers and add to esp_audio
|
|
i2s_stream_cfg_t i2s_writer = I2S_STREAM_CFG_DEFAULT();
|
|
i2s_writer.type = AUDIO_STREAM_WRITER;
|
|
i2s_writer.i2s_config.sample_rate = 48000;
|
|
esp_audio_output_stream_add(handle, i2s_stream_init(&i2s_writer));
|
|
|
|
// Set default volume
|
|
esp_audio_vol_set(handle, 60);
|
|
AUDIO_MEM_SHOW(TAG);
|
|
ESP_LOGI(TAG, "esp_audio instance is:%p", handle);
|
|
return handle;
|
|
}
|
|
|
|
static esp_err_t recorder_pipeline_open(void **handle)
|
|
{
|
|
audio_element_handle_t i2s_stream_reader;
|
|
audio_pipeline_handle_t recorder;
|
|
audio_pipeline_cfg_t pipeline_cfg = DEFAULT_AUDIO_PIPELINE_CONFIG();
|
|
recorder = audio_pipeline_init(&pipeline_cfg);
|
|
if (NULL == recorder) {
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
#ifdef CONFIG_ESP_LYRAT_MINI_V1_1_BOARD
|
|
i2s_stream_cfg_t i2s_cfg = I2S_STREAM_CFG_DEFAULT();
|
|
i2s_cfg.i2s_port = 1;
|
|
i2s_cfg.i2s_config.use_apll = 0;
|
|
i2s_cfg.i2s_config.sample_rate = 16000;
|
|
i2s_cfg.i2s_config.channel_format = I2S_CHANNEL_FMT_ONLY_RIGHT;
|
|
i2s_cfg.type = AUDIO_STREAM_READER;
|
|
i2s_stream_reader = i2s_stream_init(&i2s_cfg);
|
|
#else
|
|
i2s_stream_cfg_t i2s_cfg = I2S_STREAM_CFG_DEFAULT();
|
|
i2s_cfg.type = AUDIO_STREAM_READER;
|
|
i2s_stream_reader = i2s_stream_init(&i2s_cfg);
|
|
audio_element_info_t i2s_info = {0};
|
|
audio_element_getinfo(i2s_stream_reader, &i2s_info);
|
|
i2s_info.bits = 16;
|
|
i2s_info.channels = 2;
|
|
i2s_info.sample_rates = 48000;
|
|
audio_element_setinfo(i2s_stream_reader, &i2s_info);
|
|
|
|
rsp_filter_cfg_t rsp_cfg = DEFAULT_RESAMPLE_FILTER_CONFIG();
|
|
rsp_cfg.src_rate = 48000;
|
|
rsp_cfg.src_ch = 2;
|
|
rsp_cfg.dest_rate = 16000;
|
|
rsp_cfg.dest_ch = 1;
|
|
audio_element_handle_t filter = rsp_filter_init(&rsp_cfg);
|
|
#endif
|
|
|
|
raw_stream_cfg_t raw_cfg = RAW_STREAM_CFG_DEFAULT();
|
|
raw_cfg.type = AUDIO_STREAM_READER;
|
|
raw_read = raw_stream_init(&raw_cfg);
|
|
|
|
audio_pipeline_register(recorder, i2s_stream_reader, "i2s");
|
|
audio_pipeline_register(recorder, raw_read, "raw");
|
|
|
|
|
|
#ifdef CONFIG_ESP_LYRAT_MINI_V1_1_BOARD
|
|
const char *link_tag[2] = {"i2s", "raw"};
|
|
audio_pipeline_link(recorder, &link_tag[0], 2);
|
|
#else
|
|
audio_pipeline_register(recorder, filter, "filter");
|
|
const char *link_tag[3] = {"i2s", "filter", "raw"};
|
|
audio_pipeline_link(recorder, &link_tag[0], 3);
|
|
#endif
|
|
|
|
audio_pipeline_run(recorder);
|
|
ESP_LOGI(TAG, "Recorder has been created");
|
|
*handle = recorder;
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t recorder_pipeline_read(void *handle, char *data, int data_size)
|
|
{
|
|
raw_stream_read(raw_read, data, data_size);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t recorder_pipeline_close(void *handle)
|
|
{
|
|
audio_pipeline_deinit(handle);
|
|
return ESP_OK;
|
|
}
|
|
|
|
void setup_recorder(rec_callback cb, void *ctx)
|
|
{
|
|
rec_config_t eng = DEFAULT_REC_ENGINE_CONFIG();
|
|
eng.vad_off_delay_ms = 800;
|
|
eng.wakeup_time_ms = 10 * 1000;
|
|
eng.evt_cb = cb;
|
|
eng.open = recorder_pipeline_open;
|
|
eng.close = recorder_pipeline_close;
|
|
eng.fetch = recorder_pipeline_read;
|
|
eng.extension = NULL;
|
|
eng.support_encoding = false;
|
|
eng.user_data = ctx;
|
|
rec_engine_create(&eng);
|
|
}
|