#include "squeezelite.h" #include "driver/i2s.h" #include "perf_trace.h" #include #include "time.h" #define DECLARE_ALL_MIN_MAX \ DECLARE_MIN_MAX(o); \ DECLARE_MIN_MAX(s); \ DECLARE_MIN_MAX(loci2sbuf); \ DECLARE_MIN_MAX(req); \ DECLARE_MIN_MAX(rec); \ DECLARE_MIN_MAX(over); \ DECLARE_MIN_MAX(i2savailable);\ DECLARE_MIN_MAX(i2s_time); \ DECLARE_MIN_MAX(buffering); #define RESET_ALL_MIN_MAX \ RESET_MIN_MAX(o); \ RESET_MIN_MAX(s); \ RESET_MIN_MAX(loci2sbuf); \ RESET_MIN_MAX(req); \ RESET_MIN_MAX(rec); \ RESET_MIN_MAX(over); \ RESET_MIN_MAX(i2savailable);\ RESET_MIN_MAX(i2s_time);\ RESET_MIN_MAX(buffering); #define STATS_PERIOD_MS 5000 // Prevent compile errors if dac output is // included in the build and not actually activated in menuconfig #ifndef CONFIG_I2S_BCK_IO #define CONFIG_I2S_BCK_IO -1 #endif #ifndef CONFIG_I2S_WS_IO #define CONFIG_I2S_WS_IO -1 #endif #ifndef CONFIG_I2S_DO_IO #define CONFIG_I2S_DO_IO -1 #endif #ifndef CONFIG_I2S_NUM #define CONFIG_I2S_NUM -1 #endif static log_level loglevel; size_t dac_buffer_size =0; static bool running = true; static bool isI2SStarted=false; extern struct outputstate output; extern struct buffer *streambuf; extern struct buffer *outputbuf; extern u8_t *silencebuf; static struct buffer _dac_buffer_structure; struct buffer *dacbuffer=&_dac_buffer_structure; u8_t *tfr_buffer; static i2s_config_t i2s_config; #if REPACK && BYTES_PER_FRAMES == 4 #error "REPACK is not compatible with BYTES_PER_FRAME=4" #endif #define LOCK mutex_lock(outputbuf->mutex) #define UNLOCK mutex_unlock(outputbuf->mutex) #define FRAME_BLOCK MAX_SILENCE_FRAMES #define FRAME_TO_BYTES(f) f*out_bytes_per_frame #define BYTES_TO_FRAME(b) b/out_bytes_per_frame static int out_bytes_per_frame; static thread_type thread; static thread_type stats_thread; DECLARE_ALL_MIN_MAX; static int _dac_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR, s32_t cross_gain_in, s32_t cross_gain_out, ISAMPLE_T **cross_ptr); static void *output_thread_dac(); static void *output_thread_dac_stats(); /**************************************************************************************** * set output volume */ void set_volume_dac(unsigned left, unsigned right) { LOG_DEBUG("setting internal gain left: %u right: %u", left, right); LOCK; output.gainL = left; output.gainR = right; UNLOCK; } /**************************************************************************************** * Initialize the DAC output */ void output_init_dac(log_level level, char *device, unsigned output_buf_size, char *params, unsigned rates[], unsigned rate_delay, unsigned idle) { loglevel = level; LOG_INFO("Init output DAC."); LOG_DEBUG("Setting output parameters."); memset(&output, 0, sizeof(output)); #ifdef CONFIG_I2S_BITS_PER_CHANNEL switch (CONFIG_I2S_BITS_PER_CHANNEL) { case 24: output.format = S24_BE; break; case 16: output.format = S16_BE; break; case 8: output.format = S8_BE; break; default: LOG_ERROR("Unsupported bit depth %d",CONFIG_I2S_BITS_PER_CHANNEL); break; } #else output.format = S16_LE; #endif // ensure output rate is specified to avoid test open if (!rates[0]) { rates[0] = 44100; } running=true; // todo: move this to a hardware abstraction layer //hal_dac_init(device); // get common output configuration details output_init_common(level, device, output_buf_size, rates, idle); out_bytes_per_frame = get_bytes_per_frame(output.format); output.start_frames = FRAME_BLOCK; output.write_cb = &_dac_write_frames; output.rate_delay = rate_delay; i2s_config.mode = I2S_MODE_MASTER | I2S_MODE_TX; // Only TX i2s_config.sample_rate = output.current_sample_rate; i2s_config.bits_per_sample = get_bytes_per_frame(output.format) * 8/2; i2s_config.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT; //2-channels i2s_config.communication_format = I2S_COMM_FORMAT_I2S| I2S_COMM_FORMAT_I2S_MSB; // todo: tune this parameter. Expressed in number of samples. Byte size depends on bit depth. i2s_config.dma_buf_count = 10; // From the I2S driver source, the DMA buffer size is 4092 bytes. // so buf_len * 2 channels * 2 bytes/sample should be < 4092 or else it will be resized. i2s_config.dma_buf_len = FRAME_BLOCK/2; i2s_config.use_apll = false; i2s_config.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1; //Interrupt level 1 i2s_pin_config_t pin_config = { .bck_io_num = CONFIG_I2S_BCK_IO, .ws_io_num = CONFIG_I2S_WS_IO, .data_out_num = CONFIG_I2S_DO_IO, .data_in_num = -1 //Not used }; LOG_INFO("Initializing I2S with rate: %d, bits per sample: %d, buffer len: %d, number of buffers: %d ", i2s_config.sample_rate, i2s_config.bits_per_sample, i2s_config.dma_buf_len, i2s_config.dma_buf_count); i2s_driver_install(CONFIG_I2S_NUM, &i2s_config, 0, NULL); i2s_set_pin(CONFIG_I2S_NUM, &pin_config); i2s_set_clk(CONFIG_I2S_NUM, output.current_sample_rate, i2s_config.bits_per_sample, 2); isI2SStarted=false; i2s_stop(CONFIG_I2S_NUM); dac_buffer_size = 5*FRAME_BLOCK*get_bytes_per_frame(output.format); LOG_DEBUG("Allocating local DAC transfer buffer of %u bytes.",dac_buffer_size); buf_init(dacbuffer,dac_buffer_size ); if (!dacbuffer->buf) { LOG_ERROR("unable to malloc i2s buffer"); local_exit(0); } PTHREAD_SET_NAME("output_dac"); #if LINUX || OSX || FREEBSD || POSIX pthread_attr_t attr; pthread_attr_init(&attr); #ifdef PTHREAD_STACK_MIN pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN + OUTPUT_THREAD_STACK_SIZE); #endif pthread_create(&thread, &attr, output_thread_dac, NULL); pthread_attr_destroy(&attr); #endif #if WIN thread = CreateThread(NULL, OUTPUT_THREAD_STACK_SIZE, (LPTHREAD_START_ROUTINE)&output_thread_dac, NULL, 0, NULL); #endif PTHREAD_SET_NAME("output_dac_sts"); #if LINUX || OSX || FREEBSD || POSIX pthread_attr_init(&attr); #ifdef PTHREAD_STACK_MIN pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN+OUTPUT_THREAD_STACK_SIZE ); #endif pthread_create(&stats_thread, &attr, output_thread_dac_stats, NULL); pthread_attr_destroy(&attr); #endif #if WIN thread = CreateThread(NULL, OUTPUT_THREAD_STACK_SIZE, (LPTHREAD_START_ROUTINE)&output_thread_dac_stats, NULL, 0, NULL); #endif LOG_INFO("Init completed."); } /**************************************************************************************** * Terminate DAC output */ void output_close_dac(void) { LOG_INFO("close output"); LOCK; running = false; UNLOCK; i2s_driver_uninstall(CONFIG_I2S_NUM); output_close_common(); buf_destroy(dacbuffer); } /**************************************************************************************** * Write frames to the output buffer */ static int _dac_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR, s32_t cross_gain_in, s32_t cross_gain_out, ISAMPLE_T **cross_ptr) { size_t actual_out_bytes=FRAME_TO_BYTES(out_frames); assert(out_bytes_per_frame>0); if (!silence) { if (output.fade == FADE_ACTIVE && output.fade_dir == FADE_CROSS && *cross_ptr) { _apply_cross(outputbuf, out_frames, cross_gain_in, cross_gain_out, cross_ptr); } #if !REPACK if (gainL != FIXED_ONE || gainR!= FIXED_ONE) { _apply_gain(outputbuf, out_frames, gainL, gainR); } IF_DSD( if (output.outfmt == DOP) { update_dop((u32_t *) outputbuf->readp, out_frames, output.invert); } else if (output.outfmt != PCM && output.invert) dsd_invert((u32_t *) outputbuf->readp, out_frames); ) memcpy(dacbuffer->writep, outputbuf->readp, actual_out_bytes); #else obuf = outputbuf->readp; #endif } else { #if !REPACK IF_DSD( if (output.outfmt != PCM) { obuf = silencebuf_dsd; update_dop((u32_t *) obuf, out_frames, false); // don't invert silence } ) memcpy(dacbuffer->writep, silencebuf, actual_out_bytes); #endif } #if REPACK _scale_and_pack_frames(optr, (s32_t *)(void *)obuf, out_frames, gainL, gainR, output.format); #endif _buf_inc_writep(dacbuffer,actual_out_bytes); return (int)BYTES_TO_FRAME(actual_out_bytes); } static void *output_thread_dac_stats() { while (running) { LOCK; output_state state = output.state; UNLOCK; if(state>OUTPUT_STOPPED){ LOG_INFO( "Output State: %d, current sample rate: %d, bytes per frame: %d",state,output.current_sample_rate, out_bytes_per_frame); LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD1); LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD2); LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD3); LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD4); LOG_INFO(LINE_MIN_MAX_FORMAT_STREAM, LINE_MIN_MAX_STREAM("stream",s)); LOG_INFO(LINE_MIN_MAX_FORMAT,LINE_MIN_MAX("output",o)); LOG_INFO(LINE_MIN_MAX_FORMAT,LINE_MIN_MAX("dac buf used",loci2sbuf)); LOG_INFO(LINE_MIN_MAX_FORMAT_FOOTER); LOG_INFO(LINE_MIN_MAX_FORMAT,LINE_MIN_MAX("i2swrite",i2savailable)); LOG_INFO(LINE_MIN_MAX_FORMAT,LINE_MIN_MAX("requested",req)); LOG_INFO(LINE_MIN_MAX_FORMAT,LINE_MIN_MAX("received",rec)); LOG_INFO(LINE_MIN_MAX_FORMAT,LINE_MIN_MAX("overflow",over)); LOG_INFO(LINE_MIN_MAX_FORMAT_FOOTER); LOG_INFO(""); LOG_INFO(" ----------+----------+-----------+-----------+ "); LOG_INFO(" max (us) | min (us) | avg(us) | count | "); LOG_INFO(" ----------+----------+-----------+-----------+ "); LOG_INFO(LINE_MIN_MAX_DURATION_FORMAT,LINE_MIN_MAX_DURATION("Buffering(us)",buffering)); LOG_INFO(LINE_MIN_MAX_DURATION_FORMAT,LINE_MIN_MAX_DURATION("i2s tfr(us)",i2s_time)); LOG_INFO(" ----------+----------+-----------+-----------+"); RESET_ALL_MIN_MAX; } usleep(STATS_PERIOD_MS *1000); } return NULL; } /**************************************************************************************** * Main output thread */ static void *output_thread_dac() { frames_t frames=0; frames_t available_frames_space=0; size_t bytes_to_send_i2s=0, // Contiguous buffer which can be addressed i2s_bytes_written = 0, i2s_total_bytes_written=0; //actual size that the i2s port was able to write uint32_t timer_start=0; static int count = 0; output_state state; while (running) { i2s_bytes_written=0; frames=0; available_frames_space=0; bytes_to_send_i2s=0, // Contiguous buffer which can be addressed i2s_bytes_written = 0; //actual size that the i2s port was able to write TIME_MEASUREMENT_START(timer_start); LOCK; state =output.state; if (output.state == OUTPUT_OFF) { UNLOCK; LOG_INFO("Output state is off."); LOG_SDEBUG("Current buffer free: %10d, cont read: %10d",_buf_space(dacbuffer),_buf_cont_read(dacbuffer)); if(isI2SStarted) { isI2SStarted=false; i2s_stop(CONFIG_I2S_NUM); } usleep(200000); continue; } LOG_SDEBUG("Current buffer free: %10d, cont read: %10d",_buf_space(dacbuffer),_buf_cont_read(dacbuffer)); output.device_frames =0; output.updated = gettime_ms(); output.frames_played_dmp = output.frames_played; do{ // fill our buffer available_frames_space = BYTES_TO_FRAME(min(_buf_space(dacbuffer), _buf_cont_write(dacbuffer))); if(available_frames_space) { frames = _output_frames( available_frames_space ); // Keep the transfer buffer full SET_MIN_MAX( available_frames_space,req); SET_MIN_MAX(frames,rec); } }while(available_frames_space>0 && frames>0); SET_MIN_MAX_SIZED(_buf_used(outputbuf),o,outputbuf->size); SET_MIN_MAX_SIZED(_buf_used(streambuf),s,streambuf->size); UNLOCK; LOG_SDEBUG("Current buffer free: %10d, cont read: %10d",_buf_space(dacbuffer),_buf_cont_read(dacbuffer)); SET_MIN_MAX( TIME_MEASUREMENT_GET(timer_start),buffering); SET_MIN_MAX_SIZED(_buf_used(dacbuffer),loci2sbuf,dacbuffer->size); bytes_to_send_i2s = _buf_cont_read(dacbuffer); SET_MIN_MAX(bytes_to_send_i2s,i2savailable); i2s_total_bytes_written=0; while (bytes_to_send_i2s>0 ) { // now send all the data TIME_MEASUREMENT_START(timer_start); if(!isI2SStarted) { isI2SStarted=true; LOG_INFO("Restarting I2S."); i2s_start(CONFIG_I2S_NUM); if( i2s_config.sample_rate != output.current_sample_rate) { i2s_config.sample_rate = output.current_sample_rate; i2s_set_sample_rates(CONFIG_I2S_NUM, i2s_config.sample_rate); } } count++; LOG_SDEBUG("Outputting to I2S"); LOG_SDEBUG("Current buffer free: %10d, cont read: %10d",_buf_space(dacbuffer),_buf_cont_read(dacbuffer)); i2s_write(CONFIG_I2S_NUM, dacbuffer->readp,bytes_to_send_i2s, &i2s_bytes_written, portMAX_DELAY); _buf_inc_readp(dacbuffer,i2s_bytes_written); if(i2s_bytes_written!=bytes_to_send_i2s) { LOG_WARN("I2S DMA Overflow! available bytes: %d, I2S wrote %d bytes", bytes_to_send_i2s,i2s_bytes_written); } LOG_SDEBUG("DONE Outputting to I2S. Wrote: %d bytes out of %d", i2s_bytes_written,bytes_to_send_i2s); LOG_SDEBUG("Current buffer free: %10d, cont read: %10d",_buf_space(dacbuffer),_buf_cont_read(dacbuffer)); i2s_total_bytes_written+=i2s_bytes_written; SET_MIN_MAX( TIME_MEASUREMENT_GET(timer_start),i2s_time); if(bytes_to_send_i2s>0) { SET_MIN_MAX(bytes_to_send_i2s-i2s_bytes_written,over); } bytes_to_send_i2s = _buf_cont_read(dacbuffer); SET_MIN_MAX(bytes_to_send_i2s,i2savailable); } } return 0; } bool test_open(const char *device, unsigned rates[], bool userdef_rates) { unsigned _rates[] = { 96000, 88200, 48000, 44100, 32000, 0 }; memcpy(rates, _rates, sizeof(_rates)); return true; }