Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-08 20:47:08 +03:00
Code Issues Packages Projects Releases Wiki Activity

fix some compile issue & add TAS5713

Browse Source
This commit is contained in:
Philippe G
2020-08-03 13:19:47 -07:00
parent 0865496d76
commit 05e3c59a46
8 changed files with 48 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
components/display/ILI9341.c
View File

@@ -285,24 +285,15 @@ uint16_t unset_mac_bit(mac_bits bit, uint16_t val){
return ~(1 << bit) & val; return ~(1 << bit) & val;
} }
static void SetHFlip( struct GDS_Device* Device, bool On ) { static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) {
struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private; struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
Private->ReMap = On ? (Private->ReMap & ~(1 << MAC_BIT_MX)) : (Private->ReMap | (1 << MAC_BIT_MX)); Private->ReMap = HFlip ? (Private->ReMap & ~(1 << MAC_BIT_MX)) : (Private->ReMap | (1 << MAC_BIT_MX));
Private->ReMap = VFlip ? (Private->ReMap | (1 << MAC_BIT_MY)) : (Private->ReMap & ~(1 << MAC_BIT_MY));
Device->WriteCommand( Device, L1_CMD_MEMORY_ACCESS_CONTROL ); Device->WriteCommand( Device, L1_CMD_MEMORY_ACCESS_CONTROL );
Device->WriteData( Device, &Private->ReMap, 1 ); Device->WriteData( Device, &Private->ReMap, 1 );
WriteDataByte(Device,0x00); WriteDataByte(Device,0x00);
} }
static void SetVFlip( struct GDS_Device *Device, bool On ) {
struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
Private->ReMap = On ? (Private->ReMap | (1 << MAC_BIT_MY)) : (Private->ReMap & ~(1 << MAC_BIT_MY));
Device->WriteCommand( Device, 0xA0 );
Device->WriteData( Device, &Private->ReMap, 1 );
WriteDataByte(Device,0x00);
}
static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, L1_CMD_DISPLAY_ON ); } static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, L1_CMD_DISPLAY_ON ); }
static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, L1_CMD_DISPLAY_OFF ); } static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, L1_CMD_DISPLAY_OFF ); }
@@ -356,7 +347,7 @@ static bool Init( struct GDS_Device* Device ) {
static const struct GDS_Device ILI9341 = { static const struct GDS_Device ILI9341 = {
.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast, .DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
.SetVFlip = SetVFlip, .SetHFlip = SetHFlip, .SetLayout = SetLayout,
.Update = Update, .Init = Init, .Update = Update, .Init = Init,
}; };

1
components/services/accessors.c
View File

@@ -71,6 +71,7 @@ const display_config_t * config_display_get(){
if ((p = strcasestr(config, "speed")) != NULL) dstruct.speed = atoi(strchr(p, '=') + 1); if ((p = strcasestr(config, "speed")) != NULL) dstruct.speed = atoi(strchr(p, '=') + 1);
dstruct.hflip= strcasestr(config, "HFlip") ? true : false; dstruct.hflip= strcasestr(config, "HFlip") ? true : false;
dstruct.vflip= strcasestr(config, "VFlip") ? true : false; dstruct.vflip= strcasestr(config, "VFlip") ? true : false;
dstruct.rotate= strcasestr(config, "rotate") ? true : false;
return &dstruct; return &dstruct;
} }

1
components/services/accessors.h
View File

@@ -23,6 +23,7 @@ typedef struct {
char *type; char *type;
bool hflip; bool hflip;
bool vflip; bool vflip;
bool rotate;
} display_config_t; } display_config_t;
const display_config_t * config_display_get(); const display_config_t * config_display_get();
esp_err_t config_i2c_set(const i2c_config_t * config, int port); esp_err_t config_i2c_set(const i2c_config_t * config, int port);

4
components/squeezelite/ac101/ac101.c
View File

@@ -48,7 +48,7 @@ static const char TAG[] = "AC101";
return b;\ return b;\
} }
static bool init(char *config, int i2c_port_num); static bool init(char *config, int i2c_port_num, i2s_config_t *i2s_config);
static void deinit(void); static void deinit(void);
static void speaker(bool active); static void speaker(bool active);
static void headset(bool active); static void headset(bool active);
@@ -70,7 +70,7 @@ static int i2c_port;
/**************************************************************************************** /****************************************************************************************
* init * init
*/ */
static bool init(char *config, int i2c_port_num) { static bool init(char *config, int i2c_port_num, i2s_config_t *i2s_config) {
esp_err_t res = ESP_OK; esp_err_t res = ESP_OK;
char *p; char *p;

3
components/squeezelite/adac.h
View File

@@ -16,7 +16,7 @@ typedef enum { ADAC_ON = 0, ADAC_STANDBY, ADAC_OFF } adac_power_e;
struct adac_s { struct adac_s {
char *model; char *model;
bool (*init)(char *config, int i2c_port_num); bool (*init)(char *config, int i2c_port_num, i2s_config_t *i2s_config);
void (*deinit)(void); void (*deinit)(void);
void (*power)(adac_power_e mode); void (*power)(adac_power_e mode);
void (*speaker)(bool active); void (*speaker)(bool active);
@@ -25,5 +25,6 @@ struct adac_s {
}; };
extern const struct adac_s dac_tas57xx; extern const struct adac_s dac_tas57xx;
extern const struct adac_s dac_tas5713;
extern const struct adac_s dac_ac101; extern const struct adac_s dac_ac101;
extern const struct adac_s dac_external; extern const struct adac_s dac_external;

4
components/squeezelite/external/dac_external.c vendored
View File

@@ -25,7 +25,7 @@ static void speaker(bool active) { }
static void headset(bool active) { } static void headset(bool active) { }
static bool volume(unsigned left, unsigned right) { return false; } static bool volume(unsigned left, unsigned right) { return false; }
static void power(adac_power_e mode); static void power(adac_power_e mode);
static bool init(char *config, int i2c_port_num); static bool init(char *config, int i2c_port_num, i2s_config_t *i2s_config);
static bool i2c_json_execute(char *set); static bool i2c_json_execute(char *set);
static esp_err_t i2c_write_reg(uint8_t reg, uint8_t val); static esp_err_t i2c_write_reg(uint8_t reg, uint8_t val);
@@ -38,7 +38,7 @@ static cJSON *i2c_json;
/**************************************************************************************** /****************************************************************************************
* init * init
*/ */
static bool init(char *config, int i2c_port_num) { static bool init(char *config, int i2c_port_num, i2s_config_t *i2s_config) {
char *p; char *p;
i2c_port = i2c_port_num; i2c_port = i2c_port_num;

71
components/squeezelite/output_i2s.c
View File

@@ -77,7 +77,7 @@ extern struct buffer *streambuf;
extern struct buffer *outputbuf; extern struct buffer *outputbuf;
extern u8_t *silencebuf; extern u8_t *silencebuf;
const struct adac_s *dac_set[] = { &dac_tas57xx, &dac_ac101, NULL }; const struct adac_s *dac_set[] = { &dac_tas57xx, &dac_tas5713, &dac_ac101, NULL };
const struct adac_s *adac = &dac_external; const struct adac_s *adac = &dac_external;
static log_level loglevel; static log_level loglevel;
@@ -85,7 +85,6 @@ static log_level loglevel;
static bool jack_mutes_amp; static bool jack_mutes_amp;
static bool running, isI2SStarted; static bool running, isI2SStarted;
static i2s_config_t i2s_config; static i2s_config_t i2s_config;
static int bytes_per_frame;
static u8_t *obuf; static u8_t *obuf;
static frames_t oframes; static frames_t oframes;
static bool spdif; static bool spdif;
@@ -158,31 +157,14 @@ void output_init_i2s(log_level level, char *device, unsigned output_buf_size, ch
jack_mutes_amp = (strcmp(p,"1") == 0 ||strcasecmp(p,"y") == 0); jack_mutes_amp = (strcmp(p,"1") == 0 ||strcasecmp(p,"y") == 0);
free(p); free(p);
#ifdef CONFIG_I2S_BITS_PER_CHANNEL #if BYTES_PER_FRAME == 8
switch (CONFIG_I2S_BITS_PER_CHANNEL) { output.format = S32_LE;
case 24:
output.format = S24_BE;
bytes_per_frame = 2*3;
break;
case 16:
output.format = S16_BE;
bytes_per_frame = 2*2;
break;
case 8:
output.format = S8_BE;
bytes_per_frame = 2*4;
break;
default:
LOG_ERROR("Unsupported bit depth %d",CONFIG_I2S_BITS_PER_CHANNEL);
break;
}
#else #else
output.format = S16_LE; output.format = S16_LE;
bytes_per_frame = 2*2;
#endif #endif
output.write_cb = &_i2s_write_frames; output.write_cb = &_i2s_write_frames;
obuf = malloc(FRAME_BLOCK * bytes_per_frame); obuf = malloc(FRAME_BLOCK * BYTES_PER_FRAME);
if (!obuf) { if (!obuf) {
LOG_ERROR("Cannot allocate i2s buffer"); LOG_ERROR("Cannot allocate i2s buffer");
return; return;
@@ -240,6 +222,13 @@ void output_init_i2s(log_level level, char *device, unsigned output_buf_size, ch
gpio_set_level(i2s_pin_config.data_out_num, 0); gpio_set_level(i2s_pin_config.data_out_num, 0);
} }
i2s_config.sample_rate = output.current_sample_rate;
i2s_config.bits_per_sample = BYTES_PER_FRAME * 8 / 2;
// Counted in frames (but i2s allocates a buffer <= 4092 bytes)
i2s_config.dma_buf_len = DMA_BUF_LEN;
i2s_config.dma_buf_count = DMA_BUF_COUNT;
dma_buf_frames = DMA_BUF_COUNT * DMA_BUF_LEN;
char *dac_config = config_alloc_get_str("dac_config", CONFIG_DAC_CONFIG, "model=i2s,bck=" STR(CONFIG_I2S_BCK_IO) char *dac_config = config_alloc_get_str("dac_config", CONFIG_DAC_CONFIG, "model=i2s,bck=" STR(CONFIG_I2S_BCK_IO)
",ws=" STR(CONFIG_I2S_WS_IO) ",do=" STR(CONFIG_I2S_DO_IO) ",ws=" STR(CONFIG_I2S_WS_IO) ",do=" STR(CONFIG_I2S_DO_IO)
",sda=" STR(CONFIG_I2C_SDA) ",scl=" STR(CONFIG_I2C_SCL) ",sda=" STR(CONFIG_I2C_SDA) ",scl=" STR(CONFIG_I2C_SCL)
@@ -248,7 +237,7 @@ void output_init_i2s(log_level level, char *device, unsigned output_buf_size, ch
if ((p = strcasestr(dac_config, "model")) != NULL) sscanf(p, "%*[^=]=%31[^,]", model); if ((p = strcasestr(dac_config, "model")) != NULL) sscanf(p, "%*[^=]=%31[^,]", model);
for (int i = 0; adac == &dac_external && dac_set[i]; i++) if (strcasestr(dac_set[i]->model, model)) adac = dac_set[i]; for (int i = 0; adac == &dac_external && dac_set[i]; i++) if (strcasestr(dac_set[i]->model, model)) adac = dac_set[i];
res = adac->init(dac_config, I2C_PORT) ? ESP_OK : ESP_FAIL; res = adac->init(dac_config, I2C_PORT, &i2s_config) ? ESP_OK : ESP_FAIL;
if ((p = strcasestr(dac_config, "bck")) != NULL) i2s_pin_config.bck_io_num = atoi(strchr(p, '=') + 1); if ((p = strcasestr(dac_config, "bck")) != NULL) i2s_pin_config.bck_io_num = atoi(strchr(p, '=') + 1);
if ((p = strcasestr(dac_config, "ws")) != NULL) i2s_pin_config.ws_io_num = atoi(strchr(p, '=') + 1); if ((p = strcasestr(dac_config, "ws")) != NULL) i2s_pin_config.ws_io_num = atoi(strchr(p, '=') + 1);
@@ -262,13 +251,6 @@ void output_init_i2s(log_level level, char *device, unsigned output_buf_size, ch
free(dac_config); free(dac_config);
i2s_config.sample_rate = output.current_sample_rate;
i2s_config.bits_per_sample = bytes_per_frame * 8 / 2;
// Counted in frames (but i2s allocates a buffer <= 4092 bytes)
i2s_config.dma_buf_len = DMA_BUF_LEN;
i2s_config.dma_buf_count = DMA_BUF_COUNT;
dma_buf_frames = DMA_BUF_COUNT * DMA_BUF_LEN;
res |= i2s_driver_install(CONFIG_I2S_NUM, &i2s_config, 0, NULL); res |= i2s_driver_install(CONFIG_I2S_NUM, &i2s_config, 0, NULL);
res |= i2s_set_pin(CONFIG_I2S_NUM, &i2s_pin_config); res |= i2s_set_pin(CONFIG_I2S_NUM, &i2s_pin_config);
@@ -377,13 +359,13 @@ static int _i2s_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32
_apply_gain(outputbuf, out_frames, gainL, gainR); _apply_gain(outputbuf, out_frames, gainL, gainR);
} }
memcpy(obuf + oframes * bytes_per_frame, outputbuf->readp, out_frames * bytes_per_frame); memcpy(obuf + oframes * BYTES_PER_FRAME, outputbuf->readp, out_frames * BYTES_PER_FRAME);
#else #else
optr = (s32_t*) outputbuf->readp; optr = (s32_t*) outputbuf->readp;
#endif #endif
} else { } else {
#if BYTES_PER_FRAME == 4 #if BYTES_PER_FRAME == 4
memcpy(obuf + oframes * bytes_per_frame, silencebuf, out_frames * bytes_per_frame); memcpy(obuf + oframes * BYTES_PER_FRAME, silencebuf, out_frames * BYTES_PER_FRAME);
#else #else
optr = (s32_t*) silencebuf; optr = (s32_t*) silencebuf;
#endif #endif
@@ -397,10 +379,10 @@ static int _i2s_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32
dsd_invert((u32_t *) optr, out_frames); dsd_invert((u32_t *) optr, out_frames);
) )
_scale_and_pack_frames(obuf + oframes * bytes_per_frame, optr, out_frames, gainL, gainR, output.format); _scale_and_pack_frames(obuf + oframes * BYTES_PER_FRAME, optr, out_frames, gainL, gainR, output.format);
#endif #endif
output_visu_export((s16_t*) (obuf + oframes * bytes_per_frame), out_frames, output.current_sample_rate, silence, (gainL + gainR) / 2); output_visu_export((s16_t*) (obuf + oframes * BYTES_PER_FRAME), out_frames, output.current_sample_rate, silence, (gainL + gainR) / 2);
oframes += out_frames; oframes += out_frames;
@@ -509,8 +491,8 @@ static void *output_thread_i2s(void *arg) {
/* /*
if (synced) if (synced)
// can sleep for a buffer_queue - 1 and then eat a buffer (discard) if we are synced // can sleep for a buffer_queue - 1 and then eat a buffer (discard) if we are synced
usleep(((DMA_BUF_COUNT - 1) * DMA_BUF_LEN * bytes_per_frame * 1000) / 44100 * 1000); usleep(((DMA_BUF_COUNT - 1) * DMA_BUF_LEN * BYTES_PER_FRAME * 1000) / 44100 * 1000);
discard = DMA_BUF_COUNT * DMA_BUF_LEN * bytes_per_frame; discard = DMA_BUF_COUNT * DMA_BUF_LEN * BYTES_PER_FRAME;
} }
*/ */
i2s_config.sample_rate = output.current_sample_rate; i2s_config.sample_rate = output.current_sample_rate;
@@ -523,20 +505,25 @@ static void *output_thread_i2s(void *arg) {
} }
// run equalizer // run equalizer
equalizer_process(obuf, oframes * bytes_per_frame, output.current_sample_rate); equalizer_process(obuf, oframes * BYTES_PER_FRAME, output.current_sample_rate);
// we assume that here we have been able to entirely fill the DMA buffers // we assume that here we have been able to entirely fill the DMA buffers
if (spdif) { if (spdif) {
spdif_convert((ISAMPLE_T*) obuf, oframes, (u32_t*) sbuf, &count); spdif_convert((ISAMPLE_T*) obuf, oframes, (u32_t*) sbuf, &count);
i2s_write(CONFIG_I2S_NUM, sbuf, oframes * 16, &bytes, portMAX_DELAY); i2s_write(CONFIG_I2S_NUM, sbuf, oframes * 16, &bytes, portMAX_DELAY);
bytes /= 4; bytes /= 4;
#if BYTES_PER_FRAME == 4
} else if (i2s_config.bits_per_sample == 32) {
i2s_write_expand(CONFIG_I2S_NUM, obuf, oframes * BYTES_PER_FRAME, 16, 32, &bytes, portMAX_DELAY);
#endif
} else { } else {
i2s_write(CONFIG_I2S_NUM, obuf, oframes * bytes_per_frame, &bytes, portMAX_DELAY); i2s_write(CONFIG_I2S_NUM, obuf, oframes * BYTES_PER_FRAME, &bytes, portMAX_DELAY);
} }
fullness = gettime_ms(); fullness = gettime_ms();
if (bytes != oframes * bytes_per_frame) { if (bytes != oframes * BYTES_PER_FRAME) {
LOG_WARN("I2S DMA Overflow! available bytes: %d, I2S wrote %d bytes", oframes * bytes_per_frame, bytes); LOG_WARN("I2S DMA Overflow! available bytes: %d, I2S wrote %d bytes", oframes * BYTES_PER_FRAME, bytes);
} }
SET_MIN_MAX( TIME_MEASUREMENT_GET(timer_start),i2s_time); SET_MIN_MAX( TIME_MEASUREMENT_GET(timer_start),i2s_time);
@@ -557,7 +544,7 @@ static void *output_thread_i2s_stats(void *arg) {
output_state state = output.state; output_state state = output.state;
if(stats && state>OUTPUT_STOPPED){ if(stats && state>OUTPUT_STOPPED){
LOG_INFO( "Output State: %d, current sample rate: %d, bytes per frame: %d",state,output.current_sample_rate, bytes_per_frame); LOG_INFO( "Output State: %d, current sample rate: %d, bytes per frame: %d",state,output.current_sample_rate, BYTES_PER_FRAME);
LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD1); LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD1);
LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD2); LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD2);
LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD3); LOG_INFO( LINE_MIN_MAX_FORMAT_HEAD3);

12
components/squeezelite/tas57xx/dac_57xx.c
View File

@@ -23,7 +23,7 @@
static const char TAG[] = "TAS575x/8x"; static const char TAG[] = "TAS575x/8x";
static bool init(char *config, int i2c_port_num); static bool init(char *config, int i2c_port_num, i2s_config_t *i2s_config);
static void deinit(void); static void deinit(void);
static void speaker(bool active); static void speaker(bool active);
static void headset(bool active); static void headset(bool active);
@@ -68,10 +68,10 @@ static int tas57_detect(void);
/**************************************************************************************** /****************************************************************************************
* init * init
*/ */
static bool init(char *config, int i2c_port_num) { static bool init(char *config, int i2c_port_num, i2s_config_t *i2s_config) {
i2c_port = i2c_port_num;
char *p; char *p;
i2c_port = i2c_port_num;
// configure i2c // configure i2c
i2c_config_t i2c_config = { i2c_config_t i2c_config = {
.mode = I2C_MODE_MASTER, .mode = I2C_MODE_MASTER,
@@ -131,7 +131,9 @@ static void deinit(void) {
/**************************************************************************************** /****************************************************************************************
* change volume * change volume
*/ */
static bool volume(unsigned left, unsigned right) { return false; } static bool volume(unsigned left, unsigned right) {
return false;
}
/**************************************************************************************** /****************************************************************************************
* power * power