squeezelite-esp32/main/output_dac.c

#include "squeezelite.h"
#include "driver/i2s.h"
#include "perf_trace.h"
#include <signal.h>
#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;
}