diff --git a/components/dsp_processor/dsp_processor.c b/components/dsp_processor/dsp_processor.c index 9874ca8f..11d44591 100644 --- a/components/dsp_processor/dsp_processor.c +++ b/components/dsp_processor/dsp_processor.c @@ -259,23 +259,13 @@ static inline int16_t float_to_int16_clamped(float value) { /** * */ -int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) { +int dsp_processor_worker(char *pcmChnk, uint16_t len, uint32_t samplerate, int ch) { ESP_LOGV(TAG, "%s: processing audio chunk", __func__); - const snapcastSetting_t *scSet = (const snapcastSetting_t *)p_scSet; - pcm_chunk_message_t *pcmChnk = (pcm_chunk_message_t *)p_pcmChnk; - uint32_t samplerate = scSet->sr; - if (!pcmChnk || !pcmChnk->fragment->payload) { + if (!pcmChnk) { return -1; } - int bits = scSet->bits; - int ch = scSet->ch; - - if (bits == 0) { - bits = 16; - } - if (ch == 0) { ch = 2; } @@ -285,12 +275,11 @@ int dsp_processor_worker(void *p_pcmChnk, const void *p_scSet) { ESP_LOGW(TAG, "%s: Sample rate is not set, using default: %lu", __func__, (unsigned long)samplerate); } - int16_t len = pcmChnk->fragment->size / ((bits / 8) * ch); int16_t valint; uint16_t i; // volatile needed to ensure 32 bit access volatile uint32_t *audio_tmp = - (volatile uint32_t *)(pcmChnk->fragment->payload); + (volatile uint32_t *)(pcmChnk); // Local working copy of filter parameters static filterParams_t currentFilterParams = {0}; diff --git a/components/dsp_processor/include/dsp_processor.h b/components/dsp_processor/include/dsp_processor.h index 5099dcf4..5f9c3b3c 100644 --- a/components/dsp_processor/include/dsp_processor.h +++ b/components/dsp_processor/include/dsp_processor.h @@ -25,7 +25,7 @@ enum filtertypes { void dsp_processor_init(void); void dsp_processor_uninit(void); -int dsp_processor_worker(void *pcmChnk, const void *scSet); +int dsp_processor_worker(char *pcmChnk, uint16_t len, uint32_t samplerate, int ch); esp_err_t dsp_processor_update_filter_params(filterParams_t *params); void dsp_processor_set_volome(double volume); diff --git a/components/lightsnapcast/include/player.h b/components/lightsnapcast/include/player.h index dcd69aee..dac04aa5 100644 --- a/components/lightsnapcast/include/player.h +++ b/components/lightsnapcast/include/player.h @@ -51,26 +51,20 @@ typedef struct pcmData { typedef enum codec_type_e { NONE = 0, PCM, FLAC, OGG, OPUS } codec_type_t; -typedef struct snapcastSetting_s { - uint32_t buf_ms; - uint32_t chkInFrames; - int32_t cDacLat_ms; - - codec_type_t codec; +typedef struct playerSetting_s { + uint16_t buf_ms; + uint16_t chkInFrames; + int16_t cDacLat_ms; int32_t sr; uint8_t ch; i2s_data_bit_width_t bits; +} playerSetting_t; - bool muted; - uint32_t volume; - - char *pcmBuf; - uint32_t pcmBufSize; -} snapcastSetting_t; - -int init_player(i2s_std_gpio_config_t pin_config0_, i2s_port_t i2sNum_); +int init_player(i2s_std_gpio_config_t pin_config0_, i2s_port_t i2sNum_, void (*set_mute_cb)(bool), void (*cb)(bool), bool (*lock)(bool, TickType_t)); int deinit_player(void); -int start_player(snapcastSetting_t *setting); +int start_player(void); +void pause_player(bool pause); +void stop_player_task(void); int32_t allocate_pcm_chunk_memory(pcm_chunk_message_t **pcmChunk, size_t bytes); int32_t insert_pcm_chunk(pcm_chunk_message_t *pcmChunk); @@ -87,8 +81,7 @@ int32_t player_latency_insert(int64_t newValue); int32_t get_diff_to_server(int64_t *tDiff, int64_t now); int32_t latency_buffer_full(bool *is_full); -int32_t player_send_snapcast_setting(snapcastSetting_t *setting); -int8_t player_get_snapcast_settings(snapcastSetting_t *setting); +int32_t player_send_snapcast_setting(playerSetting_t *setting); int32_t reset_latency_buffer(void); diff --git a/components/lightsnapcast/player.c b/components/lightsnapcast/player.c index ba4cb643..8395fa10 100644 --- a/components/lightsnapcast/player.c +++ b/components/lightsnapcast/player.c @@ -106,9 +106,7 @@ static QueueHandle_t snapcastSettingQueueHandle = NULL; static uint32_t i2sDmaBufCnt; static uint32_t i2sDmaBufMaxLen; - -static SemaphoreHandle_t snapcastSettingsMux = NULL; -static snapcastSetting_t currentSnapcastSetting; +static playerSetting_t *scSet; // should be used only from http_task static void tg0_timer_init(void); static void tg0_timer_deinit(void); @@ -117,11 +115,14 @@ static bool gpTimerRunning = false; static void player_task(void *pvParameters); -bool gotSettings = false; -bool playerstarted = false; +//player state +bool playerStarted = false; +bool playerPaused = false; +static SemaphoreHandle_t playerStateMux = NULL; -extern void audio_set_mute(bool mute); -extern void audio_dac_enable(bool enabled); +static void (*state_cb)(bool) = NULL; +static void (*audio_set_mute)(bool mute); +static bool (*lock_i2s)(bool, TickType_t) = NULL; static i2s_chan_handle_t tx_chan = NULL; // I2S tx channel handler static bool i2sEnabled = false; @@ -211,7 +212,14 @@ static void ensure_noiseless(i2s_chan_handle_t tx) { /** * */ -static esp_err_t player_setup_i2s(snapcastSetting_t *setting) { +static esp_err_t player_setup_i2s(playerSetting_t *setting, bool lock) { + + if (lock_i2s != NULL && lock) { + if (lock_i2s(true, pdMS_TO_TICKS(10)) != pdTRUE) { + return -1; + } + } + // ensure save setting int32_t sr = setting->sr; if (sr == 0) { @@ -390,17 +398,22 @@ int deinit_player(void) { // must disable i2s before stopping player task or it will hang my_i2s_channel_disable(tx_chan); - + + //don't take playerStateMux here, otherwise we might block player task from stopping + //if (playerStateMux != NULL) { + // xSemaphoreTake(playerStateMux, pdMS_TO_TICKS(10000)); + //} + //wait max 10s for task to stop itself for(int i = 0; i< 100; i++) { - if (playerstarted) { + if (playerStarted) { vTaskDelay(pdMS_TO_TICKS(100)); } else { break; } } - // stop the task f still running + // stop the task if still running if (playerTaskHandle != NULL) { vTaskDelete(playerTaskHandle); playerTaskHandle = NULL; @@ -410,10 +423,18 @@ int deinit_player(void) { i2s_del_channel(tx_chan); tx_chan = NULL; } + if (lock_i2s != NULL) { + lock_i2s(false, 0); + } - if (snapcastSettingsMux != NULL) { - vSemaphoreDelete(snapcastSettingsMux); - snapcastSettingsMux = NULL; + if (playerStateMux != NULL) { + vSemaphoreDelete(playerStateMux); + playerStateMux = NULL; + } + if (snapcastSettingQueueHandle != NULL) { + // delete the queue + vQueueDelete(snapcastSettingQueueHandle); + snapcastSettingQueueHandle = NULL; } ret = destroy_pcm_queue(&pcmChkQHdl); @@ -442,39 +463,42 @@ int deinit_player(void) { return ret; } +void call_state_cb(void) { + if (state_cb != NULL) { + xSemaphoreTake(playerStateMux, portMAX_DELAY); + bool paused = playerPaused; + xSemaphoreGive(playerStateMux); + state_cb(paused); + } +} + /** * call before http task creation! */ -int init_player(i2s_std_gpio_config_t pin_config0_, i2s_port_t i2sNum_) { - int ret = 0; +int init_player(i2s_std_gpio_config_t pin_config0_, i2s_port_t i2sNum_, void (*set_mute_cb)(bool), void (*cb)(bool), bool (*lock)(bool, TickType_t)) { + if (set_mute_cb == NULL) { + ESP_LOGE(TAG, "set_mute_cb is NULL"); + return -1; + } + + audio_set_mute = set_mute_cb; + state_cb = cb; // can be NULL + lock_i2s = lock; // can be NULL + deinit_player(); pin_config0 = pin_config0_; i2sNum = i2sNum_; - currentSnapcastSetting.buf_ms = 0; - currentSnapcastSetting.chkInFrames = 0; - currentSnapcastSetting.codec = NONE; - currentSnapcastSetting.sr = 0; - currentSnapcastSetting.ch = 0; - currentSnapcastSetting.bits = 0; - currentSnapcastSetting.muted = true; - currentSnapcastSetting.volume = 0; + // create message queue to inform task of changed settings + snapcastSettingQueueHandle = xQueueCreate(1, sizeof(playerSetting_t)); - if (snapcastSettingsMux == NULL) { - snapcastSettingsMux = xSemaphoreCreateMutex(); - xSemaphoreGive(snapcastSettingsMux); + if (playerStateMux == NULL) { + playerStateMux = xSemaphoreCreateMutex(); + xSemaphoreGive(playerStateMux); } - /** - ret = player_setup_i2s(¤tSnapcastSetting); - if (ret < 0) { - ESP_LOGE(TAG, "player_setup_i2s failed: %d", ret); - - return -1; - }*/ - // create semaphore for time diff buffer to server if (latencyBufSemaphoreHandle == NULL) { latencyBufSemaphoreHandle = xSemaphoreCreateMutex(); @@ -515,19 +539,30 @@ int init_player(i2s_std_gpio_config_t pin_config0_, i2s_port_t i2sNum_) { /** * call to start the player task */ -int start_player(snapcastSetting_t *setting) { - if (playerstarted){ - return -1; - } - playerstarted = true; +int start_player() { + if (xSemaphoreTake(playerStateMux, 0) != pdTRUE) { + // shutdown in progress, don't start player + return -1; + } + if (playerStarted || playerPaused){ + xSemaphoreGive(playerStateMux); + return -1; + } + if (scSet == NULL || !(( scSet->buf_ms > 0) && (scSet->chkInFrames > 0))) { + xSemaphoreGive(playerStateMux); + return -1; + } + playerStarted = true; int ret = 0; - ret = player_setup_i2s(setting); + ret = player_setup_i2s(scSet, true); if (ret < 0) { ESP_LOGE(TAG, "player_setup_i2s failed: %d", ret); - playerstarted = false; + playerStarted = false; + xSemaphoreGive(playerStateMux); return -1; } + xSemaphoreGive(playerStateMux); tg0_timer_init(); @@ -541,27 +576,15 @@ int start_player(snapcastSetting_t *setting) { esp_pm_lock_acquire(player_pm_lock_handle); #endif - // create message queue to inform task of changed settings - snapcastSettingQueueHandle = xQueueCreate(1, sizeof(uint8_t)); - if (pcmChkQHdl == NULL) { - snapcastSetting_t scSet; - memset(&scSet, 0, sizeof(snapcastSetting_t)); - player_get_snapcast_settings(&scSet); - - // ensure we don't have a divide by zero situation - uint32_t chkInFrames = scSet.chkInFrames; - if (chkInFrames == 0) { - chkInFrames = 1152; // choose a good default for now - } - int entries = ceil(((float)scSet.sr / (float)chkInFrames) * - ((float)scSet.buf_ms / 1000)); + int entries = ceil(((float)scSet->sr / (float)scSet->chkInFrames) * + ((float)scSet->buf_ms / 1000)); // some chunks are placed in DMA buffer // so we can save a little RAM here - entries -= ((i2sDmaBufMaxLen * i2sDmaBufCnt) / chkInFrames); + entries -= ((i2sDmaBufMaxLen * i2sDmaBufCnt) / scSet->chkInFrames); pcmChkQHdl = xQueueCreate(entries, sizeof(pcm_chunk_message_t *)); @@ -570,44 +593,36 @@ int start_player(snapcastSetting_t *setting) { ESP_LOGI(TAG, "Start player_task"); - xTaskCreatePinnedToCore(player_task, "player", 1024 * 3, NULL, + xTaskCreatePinnedToCore(player_task, "player", 1024 * 3, (void*) scSet, SYNC_TASK_PRIORITY, &playerTaskHandle, SYNC_TASK_CORE_ID); - + call_state_cb(); ESP_LOGI(TAG, "start player done"); return 0; } -/** - * - */ -int8_t player_set_snapcast_settings(snapcastSetting_t *setting) { - int8_t ret = pdPASS; - - xSemaphoreTake(snapcastSettingsMux, portMAX_DELAY); - - memcpy(¤tSnapcastSetting, setting, sizeof(snapcastSetting_t)); - - xSemaphoreGive(snapcastSettingsMux); - - return ret; +void pause_player(bool pause) { + xSemaphoreTake(playerStateMux, portMAX_DELAY); + if (pause != playerPaused) { + playerPaused = pause; + xSemaphoreGive(playerStateMux); + if (pause) { + stop_player_task(); + } + else { + call_state_cb(); // notify state change, e.g. for http task to send pcm + } + } else { + xSemaphoreGive(playerStateMux); + } } -/** - * - */ -int8_t player_get_snapcast_settings(snapcastSetting_t *setting) { - int8_t ret = pdPASS; - - xSemaphoreTake(snapcastSettingsMux, portMAX_DELAY); - - memcpy(setting, ¤tSnapcastSetting, sizeof(snapcastSetting_t)); - - xSemaphoreGive(snapcastSettingsMux); - - return ret; +void stop_player_task() { + if (playerTaskHandle != NULL) { + xTaskNotifyGiveIndexed(playerTaskHandle, 1); + } } #if USE_TIMEFILTER @@ -671,52 +686,23 @@ int32_t player_latency_insert(int64_t newValue) { /** * */ -int32_t player_send_snapcast_setting(snapcastSetting_t *setting) { +int32_t player_send_snapcast_setting(playerSetting_t *setting) { int ret; - snapcastSetting_t curSet; - uint8_t settingChanged = 1; - - ret = player_get_snapcast_settings(&curSet); - - if ((curSet.bits != setting->bits) || (curSet.buf_ms != setting->buf_ms) || - (curSet.ch != setting->ch) || - (curSet.chkInFrames != setting->chkInFrames) || - (curSet.codec != setting->codec) || (curSet.muted != setting->muted) || - (curSet.sr != setting->sr) || (curSet.volume != setting->volume) || - (curSet.cDacLat_ms != setting->cDacLat_ms)) { - ret = player_set_snapcast_settings(setting); + + if ((playerTaskHandle != NULL) && (snapcastSettingQueueHandle != NULL)) { + ret = xQueueOverwrite(snapcastSettingQueueHandle, setting); if (ret != pdPASS) { ESP_LOGE(TAG, - "player_send_snapcast_setting: couldn't change " - "snapcast setting"); - } - - // check if it is only volume / mute related setting, which is handled by - // http_get_task() - // if ((((curSet.muted != setting->muted) || - //(curSet.volume != setting->volume)) && - //((curSet.bits == setting->bits) && - //(curSet.buf_ms == setting->buf_ms) && (curSet.ch == setting->ch) && - //(curSet.chkInFrames == setting->chkInFrames) && - //(curSet.codec == setting->codec) && (curSet.sr == setting->sr) && - //(curSet.cDacLat_ms == setting->cDacLat_ms))) == false) { - // notify needed - if ((playerTaskHandle != NULL) && (snapcastSettingQueueHandle != NULL)) { - ret = xQueueOverwrite(snapcastSettingQueueHandle, &settingChanged); - if (ret != pdPASS) { - ESP_LOGE(TAG, - "player_send_snapcast_setting: couldn't notify " - "snapcast setting"); - } else { - ESP_LOGI(TAG, - "got settings and notified player_task"); - } + "player_send_snapcast_setting: couldn't notify " + "snapcast setting"); + } else { + ESP_LOGI(TAG, + "got settings and notified player_task"); } - } - - if (!gotSettings && (setting->bits > 0) && ( setting->buf_ms > 0) && (setting->ch > 0) && - (setting->chkInFrames > 0) && (setting->sr > 0)) { - gotSettings = true; + } else if (scSet == NULL) { + scSet = setting; + ESP_LOGI(TAG, + "got initial settings"); } return pdPASS; @@ -927,7 +913,7 @@ static bool IRAM_ATTR timer_group0_alarm_cb( uint64_t timer_counter_value = edata->count_value; // Notify the task in the task's notification value. - xTaskNotifyFromISR(playerTaskHandle, (uint32_t)timer_counter_value, + xTaskNotifyIndexedFromISR(playerTaskHandle, 0, (uint32_t)timer_counter_value, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); return xHigherPriorityTaskWoken == pdTRUE; @@ -1354,16 +1340,14 @@ int32_t insert_pcm_chunk(pcm_chunk_message_t *pcmChunk) { return -1; } + if (playerPaused) { + free_pcm_chunk(pcmChunk); + return 0; + } if (pcmChkQHdl == NULL) { - ESP_LOGW(TAG, "pcm chunk queue not created. Player started: %s", playerstarted ? "True": "False"); - + ESP_LOGW(TAG, "pcm chunk queue not created. Player started: %s", playerStarted ? "True": "False"); free_pcm_chunk(pcmChunk); - - snapcastSetting_t curSet; - player_get_snapcast_settings(&curSet); - if (!curSet.muted && gotSettings) { - start_player(&curSet); - } + start_player(); return -2; } @@ -1425,8 +1409,7 @@ static void player_task(void *pvParameters) { char *p_payload = NULL; size_t size = 0; uint32_t notifiedValue; - snapcastSetting_t scSet; - uint8_t scSetChgd = 0; + playerSetting_t scSet; uint64_t timer_val; int initialSync = 0; int dir = 0; @@ -1445,8 +1428,7 @@ static void player_task(void *pvParameters) { uint64_t samples_written = 0; UBaseType_t uxHighWaterMark; - memset(&scSet, 0, sizeof(snapcastSetting_t)); - player_get_snapcast_settings(&scSet); + memcpy(&scSet, (playerSetting_t*)pvParameters, sizeof(playerSetting_t)); ESP_LOGI(TAG, "started sync task"); @@ -1484,7 +1466,7 @@ static void player_task(void *pvParameters) { // // ESP_LOGI(TAG, "created new queue with %d", entries); // } - audio_set_mute(scSet.muted); + audio_set_mute(false); // wait for early time syncs to be ready xSemaphoreTake(latencyBufFullSemaphoreHandle, portMAX_DELAY); @@ -1506,11 +1488,9 @@ static void player_task(void *pvParameters) { // check if we got changed setting available, if so we need to // reinitialize - ret = xQueueReceive(snapcastSettingQueueHandle, &scSetChgd, 0); + playerSetting_t __scSet; + ret = xQueueReceive(snapcastSettingQueueHandle, &__scSet, 0); if (ret == pdTRUE) { - snapcastSetting_t __scSet; - - player_get_snapcast_settings(&__scSet); if ((__scSet.buf_ms > 0) && (__scSet.chkInFrames > 0) && (__scSet.sr > 0)) { @@ -1520,11 +1500,13 @@ static void player_task(void *pvParameters) { if ((scSet.sr != __scSet.sr) || (scSet.bits != __scSet.bits) || (scSet.ch != __scSet.ch)) { + ESP_LOGI(TAG, "reinitializing i2s with new settings: sample rate %ld, ch %d, bits %d", + __scSet.sr, __scSet.ch, __scSet.bits); my_i2s_channel_enable(tx_chan); audio_set_mute(true); my_i2s_channel_disable(tx_chan); - ret = player_setup_i2s(&__scSet); + ret = player_setup_i2s(&__scSet, false); if (ret < 0) { ESP_LOGE(TAG, "player_setup_i2s failed: %d", ret); @@ -1567,13 +1549,11 @@ static void player_task(void *pvParameters) { (scSet.ch != __scSet.ch) || (scSet.buf_ms != __scSet.buf_ms)) { ESP_LOGI(TAG, "snapserver config changed, buffer %ldms, chunk %ld frames, " - "sample rate %ld, ch %d, bits %d mute %d latency %ld", + "sample rate %ld, ch %d, bits %d latency %ld", __scSet.buf_ms, __scSet.chkInFrames, __scSet.sr, __scSet.ch, - __scSet.bits, __scSet.muted, __scSet.cDacLat_ms); - } else { - audio_set_mute(__scSet.muted); - ESP_LOGI(TAG, "snapserver config changed, mute: %d", __scSet.muted); + __scSet.bits, __scSet.cDacLat_ms); } + audio_set_mute(false); scSet = __scSet; // store for next round @@ -1696,7 +1676,7 @@ static void player_task(void *pvParameters) { } // Wait to be notified of a timer interrupt. - xTaskNotifyWait(pdFALSE, // Don't clear bits on entry. + xTaskNotifyWaitIndexed(0, pdFALSE, // Don't clear bits on entry. pdFALSE, // Don't clear bits on exit. ¬ifiedValue, // Stores the notified value. portMAX_DELAY); @@ -1705,8 +1685,6 @@ static void player_task(void *pvParameters) { my_gptimer_stop(gptimer); - audio_dac_enable(true); - my_i2s_channel_enable(tx_chan); playback_start_time_us = esp_timer_get_time(); @@ -1722,7 +1700,7 @@ static void player_task(void *pvParameters) { // TODO: use a timer to un-mute non blocking vTaskDelay(pdMS_TO_TICKS(2)); - audio_set_mute(scSet.muted); + audio_set_mute(false); ESP_LOGI(TAG, "initial sync age: %lldus, chunk duration: %lldus", age, chunkDuration_us); @@ -2109,37 +2087,33 @@ static void player_task(void *pvParameters) { "diff2Server: %llds, %lld.%lldms", uxQueueMessagesWaiting(pcmChkQHdl), sec, msec, usec); } - - dir = 0; - initialSync = 0; - - audio_set_mute(true); - audio_dac_enable(false); - my_i2s_channel_disable(tx_chan); - i2s_del_channel(tx_chan); - tx_chan = NULL; - + break; + } + if (ulTaskNotifyTakeIndexed(1, pdTRUE, 0) == pdTRUE) { break; } } - ret = 0; - - xSemaphoreTake(snapcastSettingsMux, portMAX_DELAY); - // delete the queue - vQueueDelete(snapcastSettingQueueHandle); - snapcastSettingQueueHandle = NULL; - xSemaphoreGive(snapcastSettingsMux); + audio_set_mute(true); + my_i2s_channel_disable(tx_chan); + i2s_del_channel(tx_chan); + tx_chan = NULL; + if (lock_i2s != NULL) { + lock_i2s(false, 0); + } + xSemaphoreTake(playerStateMux, portMAX_DELAY); #if CONFIG_PM_ENABLE esp_pm_lock_release(player_pm_lock_handle); #endif - ret = destroy_pcm_queue(&pcmChkQHdl); + destroy_pcm_queue(&pcmChkQHdl); tg0_timer_deinit(); - playerstarted = false; + playerStarted = false; ESP_LOGI(TAG, "stop player done"); playerTaskHandle = NULL; + xSemaphoreGive(playerStateMux); + call_state_cb(); vTaskDelete(NULL); } diff --git a/components/lightsnapcast/snapcast_protocol_parser.c b/components/lightsnapcast/snapcast_protocol_parser.c index 19a7d3a1..53944ffe 100644 --- a/components/lightsnapcast/snapcast_protocol_parser.c +++ b/components/lightsnapcast/snapcast_protocol_parser.c @@ -327,7 +327,5 @@ parser_return_state_t parser_skip_typed_message(snapcast_protocol_parser_t* pars if (!read_byte(parser, &dummy_byte)) return PARSER_RESTART_CONNECTION; } - ESP_LOGI(TAG, "done skipping typed message %d", base_message_rx->type); - return PARSER_OK; } diff --git a/components/ota_server/include/ota_server.h b/components/ota_server/include/ota_server.h index 30ff48dc..76e2fabb 100644 --- a/components/ota_server/include/ota_server.h +++ b/components/ota_server/include/ota_server.h @@ -9,5 +9,6 @@ extern const int OTA_CONNECTED_BIT; void ota_server_task(void *param); void ota_server_start_my(void); +void ota_on_sc_state_changed(); extern EventGroupHandle_t ota_event_group; diff --git a/components/ota_server/ota_server.c b/components/ota_server/ota_server.c index b2c4501d..50c10193 100644 --- a/components/ota_server/ota_server.c +++ b/components/ota_server/ota_server.c @@ -22,12 +22,16 @@ #include "player.h" extern TaskHandle_t t_http_get_task; +extern void sc_stop_snapclient(); +typedef enum { STOPPED = 0, IDLE, PLAYING, PAUSED } snapclient_state_t; +extern snapclient_state_t sc_get_snapclient_state(void); const int OTA_CONNECTED_BIT = BIT0; static const char *TAG = "OTA"; EventGroupHandle_t ota_event_group; /*socket*/ static int connect_socket = 0; +static TaskHandle_t otaTaskHandle = NULL; void ota_server_task(void *param) { // xEventGroupWaitBits(ota_event_group, OTA_CONNECTED_BIT, false, true, @@ -152,18 +156,52 @@ static esp_err_t create_tcp_server() { return ESP_OK; } +void ota_on_sc_state_changed() { + if (otaTaskHandle != NULL) { + xTaskNotifyGive(otaTaskHandle); + } +} + +void wait_for_sc_stopped() { + snapclient_state_t state = sc_get_snapclient_state(); + if (state == STOPPED) { + return; + } + // drain old notifications that might have come in while waiting for connection + ulTaskNotifyTake(pdTRUE, 0); + //ESP_LOGI(TAG, "Stopping snapclient..."); + sc_stop_snapclient(); + bool stopped = false; + while(!stopped) { + esp_err_t ret = ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(10000)); + if (ret != pdTRUE) { + ESP_LOGW(TAG, "wait for sc stopped: timeout"); + vTaskDelete(t_http_get_task); + break; + } + state = sc_get_snapclient_state(); + if (state == STOPPED) { + stopped = true; + } + } +} + void ota_server_start_my(void) { uint8_t percent_loaded; uint8_t old_percent_loaded; + otaTaskHandle = xTaskGetCurrentTaskHandle(); + ESP_ERROR_CHECK(create_tcp_server()); // We don't want any other thread running during this update. // SuspendAllThreads(); // KillAllThreads(); // dsp_i2s_task_deinit(); - vTaskDelete(t_http_get_task); + + wait_for_sc_stopped(); deinit_player(); // ensure this is called after http_task was killed + vTaskDelay(pdMS_TO_TICKS(200)); // short delay to ensure all resources are freed before starting OTA const esp_partition_t *update_partition = esp_ota_get_next_update_partition(NULL); @@ -229,7 +267,7 @@ void ota_server_start_my(void) { int send_len; send_len = sprintf(res_buff, "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"); send(connect_socket, res_buff, send_len, 0); - vTaskDelay(2000 / portTICK_PERIOD_MS); + vTaskDelay(pdMS_TO_TICKS(2000)); close(connect_socket); ESP_ERROR_CHECK(esp_ota_end(ota_handle)); diff --git a/main/main.c b/main/main.c index 06b070df..8becac32 100644 --- a/main/main.c +++ b/main/main.c @@ -90,6 +90,7 @@ const char *VERSION_STRING = "0.0.4"; #define OTA_TASK_CORE_ID tskNO_AFFINITY // 1 // tskNO_AFFINITY +TaskHandle_t t_main_task = NULL; TaskHandle_t t_ota_task = NULL; TaskHandle_t t_http_get_task = NULL; @@ -105,17 +106,29 @@ static const char *TAG = "SC"; // static QueueHandle_t playerChunkQueueHandle = NULL; SemaphoreHandle_t timeSyncSemaphoreHandle = NULL; -SemaphoreHandle_t idCounterSemaphoreHandle = NULL; +static SemaphoreHandle_t idCounterSemaphoreHandle = NULL; +static SemaphoreHandle_t snapclientStateChangedMutex = NULL; + +typedef struct snapcastSetting_s { + playerSetting_t playerSetting; + + bool muted; + uint32_t volume; +} snapcastSetting_t; typedef struct audioDACdata_s { - bool mute; + bool playerMute; + bool stateMute; int volume; - bool enabled; } audioDACdata_t; static audioDACdata_t audioDAC_data; static QueueHandle_t audioDACQHdl = NULL; static SemaphoreHandle_t audioDACSemaphore = NULL; +static void (*set_volume_cb)(int volume); +static void (*set_mute_cb)(bool mute, bool state); +static SemaphoreHandle_t snapclientStateMux = NULL; +static SemaphoreHandle_t i2sLockMutex = NULL; void time_sync_msg_cb(void *args); @@ -311,10 +324,10 @@ void time_sync_msg_received(base_message_t *base_message_rx, static FLAC__StreamDecoderReadStatus read_callback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data) { - snapcastSetting_t *scSet = (snapcastSetting_t *)client_data; + //snapcastSetting_t *scSet = (snapcastSetting_t *)client_data; // decoderData_t *flacData; - (void)scSet; + //(void)scSet; // xQueueReceive(decoderReadQHdl, &flacData, portMAX_DELAY); // if (xQueueReceive(decoderReadQHdl, &flacData, pdMS_TO_TICKS(100))) @@ -380,7 +393,7 @@ static FLAC__StreamDecoderWriteStatus write_callback( const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data) { size_t i; - snapcastSetting_t *scSet = (snapcastSetting_t *)client_data; + playerSetting_t *scSet = (playerSetting_t *)client_data; size_t bytes = frame->header.blocksize * frame->header.channels * frame->header.bits_per_sample / 8; @@ -467,7 +480,7 @@ static FLAC__StreamDecoderWriteStatus write_callback( void metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) { - snapcastSetting_t *scSet = (snapcastSetting_t *)client_data; + playerSetting_t *scSet = (playerSetting_t *)client_data; (void)decoder; @@ -498,58 +511,115 @@ void error_callback(const FLAC__StreamDecoder *decoder, } /** - * + * Snapclient state functions and types */ -void init_snapcast(QueueHandle_t audioQHdl) { - audioDACQHdl = audioQHdl; - audioDACSemaphore = xSemaphoreCreateMutex(); - audioDAC_data.mute = true; - audioDAC_data.volume = -1; - audioDAC_data.enabled = false; + +typedef enum { STOPPED = 0, IDLE, PLAYING, PAUSED } snapclient_state_t; +typedef enum { STOP = 0, START, RESTART, PAUSE, UNPAUSE } snapclient_commands_t; + +typedef struct state_cb_s { + void (*cb)(void); + struct state_cb_s *next; +} state_cb_t; + +static snapclient_state_t sc_state = STOPPED; +static state_cb_t *state_cb_head = NULL; + +/** + * Set mute state called by player + */ +void player_set_mute(bool mute) { + set_mute_cb(mute, false); } /** - * + * Set mute state called by snapclient */ -void audio_dac_enable(bool enabled) { - xSemaphoreTake(audioDACSemaphore, portMAX_DELAY); - if (enabled != audioDAC_data.enabled) { - audioDAC_data.enabled = enabled; - xQueueOverwrite(audioDACQHdl, &audioDAC_data); +void set_mute_state(bool mute) { + set_mute_cb(mute, true); +} + +/** + * Sends command to http task, e.g. to start snapclient or pause player. + */ +void sc_send_command(snapclient_commands_t command) { + if (t_http_get_task != NULL) { + xTaskNotify(t_http_get_task, (uint32_t) command, eSetValueWithOverwrite); } - xSemaphoreGive(audioDACSemaphore); } /** - * + * Callback for player state changes, e.g. to send pause command to snapclient when player is paused. */ -void audio_set_mute(bool mute) { - xSemaphoreTake(audioDACSemaphore, portMAX_DELAY); - if (mute != audioDAC_data.mute) { - audioDAC_data.mute = mute; - xQueueOverwrite(audioDACQHdl, &audioDAC_data); +void on_player_state_paused(bool paused) { + if (paused) { + sc_send_command(PAUSE); + } else { + sc_send_command(UNPAUSE); } - xSemaphoreGive(audioDACSemaphore); +} + +void sc_start_snapclient() { + sc_send_command(START); +} + +void sc_restart_snapclient() { + sc_send_command(RESTART); +} + +void sc_stop_snapclient() { + sc_send_command(STOP); } /** - * + * Pause snapclient. This will first pause the player. Snapclient is then paused by the player callback. */ -void audio_set_volume(int volume) { - xSemaphoreTake(audioDACSemaphore, portMAX_DELAY); - if (volume != audioDAC_data.volume) { - audioDAC_data.volume = volume; - xQueueOverwrite(audioDACQHdl, &audioDAC_data); +void sc_pause_snapclient(bool pause) { + pause_player(pause); +} + +/** + * Get snapclient state + */ +snapclient_state_t sc_get_snapclient_state(void) { + xSemaphoreTake(snapclientStateMux, portMAX_DELAY); + snapclient_state_t state = sc_state; + xSemaphoreGive(snapclientStateMux); + return state; +} + +void sc_call_state_cb(void) { + state_cb_t *current = state_cb_head; + while (current != NULL) { + if (current->cb != NULL) { + current->cb(); + } + current = current->next; } - xSemaphoreGive(audioDACSemaphore); } +/** + * add callback to be called when snapclient state changes, e.g. from not started to started. + * Callbacks needs to be implemented thread safe as they will be called from http task + */ +void sc_add_state_cb(void (*cb)()) { + state_cb_t *new_cb = malloc(sizeof(state_cb_t)); + if (new_cb == NULL) { + ESP_LOGE(TAG, "Failed to allocate memory for state callback"); + return; + } + new_cb->cb = cb; + new_cb->next = state_cb_head; + state_cb_head = new_cb; +} + + /** * */ void server_settings_msg_received( server_settings_message_t *server_settings_message, - snapcastSetting_t *scSet) { + snapcastSetting_t *scSet, bool playing) { // log mute state, buffer, latency ESP_LOGI(TAG, "Buffer length: %ld", server_settings_message->buffer_ms); ESP_LOGI(TAG, "Latency: %ld", server_settings_message->latency); @@ -558,7 +628,7 @@ void server_settings_msg_received( // Volume setting using ADF HAL // abstraction - if (scSet->muted != server_settings_message->muted) { + if (playing && scSet->muted != server_settings_message->muted) { #if SNAPCAST_USE_SOFT_VOL if (server_settings_message->muted) { dsp_processor_set_volome(0.0); @@ -566,31 +636,35 @@ void server_settings_msg_received( dsp_processor_set_volome((double)server_settings_message->volume / 100); } #endif - audio_set_mute(server_settings_message->muted); + set_mute_state(server_settings_message->muted); } - if (scSet->volume != server_settings_message->volume) { + if (playing && scSet->volume != server_settings_message->volume) { #if SNAPCAST_USE_SOFT_VOL if (!server_settings_message->muted) { dsp_processor_set_volome((double)server_settings_message->volume / 100); } #else - audio_set_volume(server_settings_message->volume); + set_volume_cb(server_settings_message->volume); #endif } - scSet->cDacLat_ms = server_settings_message->latency; - scSet->buf_ms = server_settings_message->buffer_ms; scSet->muted = server_settings_message->muted; scSet->volume = server_settings_message->volume; - if (player_send_snapcast_setting(scSet) != pdPASS) { - ESP_LOGE(TAG, - "Failed to notify sync task. " - "Did you init player?"); + if (scSet->playerSetting.cDacLat_ms != server_settings_message->latency || + scSet->playerSetting.buf_ms != server_settings_message->buffer_ms) { + scSet->playerSetting.cDacLat_ms = server_settings_message->latency; + scSet->playerSetting.buf_ms = server_settings_message->buffer_ms; - // critical error - esp_restart(); + if (playing && player_send_snapcast_setting(&(scSet->playerSetting)) != pdPASS) { + ESP_LOGE(TAG, + "Failed to notify sync task. " + "Did you init player?"); + + // critical error + esp_restart(); + } } } @@ -598,7 +672,7 @@ void server_settings_msg_received( * */ void codec_header_received(char *codecPayload, uint32_t codecPayloadLen, - codec_type_t codec, snapcastSetting_t *scSet, + codec_type_t codec, playerSetting_t *scSet, time_sync_data_t *time_sync_data) { // first ensure everything is set up // correctly and resources are @@ -624,7 +698,6 @@ void codec_header_received(char *codecPayload, uint32_t codecPayloadLen, memcpy(&bits, codecPayload + 8, sizeof(bits)); memcpy(&channels, codecPayload + 10, sizeof(channels)); - scSet->codec = codec; scSet->bits = bits; scSet->ch = channels; scSet->sr = rate; @@ -683,7 +756,6 @@ void codec_header_received(char *codecPayload, uint32_t codecPayloadLen, memcpy(&rate, codecPayload + 24, sizeof(rate)); memcpy(&bits, codecPayload + 34, sizeof(bits)); - scSet->codec = codec; scSet->bits = bits; scSet->ch = channels; scSet->sr = rate; @@ -721,9 +793,10 @@ void codec_header_received(char *codecPayload, uint32_t codecPayloadLen, /** * */ -void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, +void handle_chunk_message(codec_type_t codec, playerSetting_t *scSet, pcm_chunk_message_t **pcmData, wire_chunk_message_t *wire_chnk) { + static uint32_t chkInFrames = 0; switch (codec) { case OPUS: { int frame_size = -1; @@ -779,6 +852,20 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, // ESP_LOGW(TAG, "OPUS decode: %d", frame_size); + if (chkInFrames != scSet->chkInFrames) { + if (player_send_snapcast_setting(scSet) != pdPASS) { + ESP_LOGE(TAG, + "Failed to notify " + "sync task about " + "codec. Did you " + "init player?"); + + // critical error + esp_restart(); + } + chkInFrames = scSet->chkInFrames; + } + if (allocate_pcm_chunk_memory(&new_pcmChunk, bytes) < 0) { *pcmData = NULL; } else { @@ -805,24 +892,15 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, #if CONFIG_USE_DSP_PROCESSOR if (new_pcmChunk->fragment->payload) { - dsp_processor_worker((void *)new_pcmChunk, (void *)scSet); + dsp_processor_worker(new_pcmChunk->fragment->payload, + new_pcmChunk->fragment->size / ((scSet->bits / 8) * scSet->ch), + scSet->sr, scSet->ch); } #endif insert_pcm_chunk(new_pcmChunk); } - if (player_send_snapcast_setting(scSet) != pdPASS) { - ESP_LOGE(TAG, - "Failed to notify " - "sync task about " - "codec. Did you " - "init player?"); - - // critical error - esp_restart(); - } - break; } @@ -866,6 +944,21 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, // ESP_LOGI(TAG, "new_pcmChunk with size %ld", // new_pcmChunk->totalSize); + + if (chkInFrames != scSet->chkInFrames) { + if (player_send_snapcast_setting(scSet) != pdPASS) { + ESP_LOGE(TAG, + "Failed to notify " + "sync task about " + "codec. Did you " + "init player?"); + + // critical error + esp_restart(); + } + chkInFrames = scSet->chkInFrames; + } + if (ret == 0) { pcm_chunk_fragment_t *fragment = new_pcmChunk->fragment; uint32_t fragmentCnt = 0; @@ -900,7 +993,9 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, #if CONFIG_USE_DSP_PROCESSOR if (new_pcmChunk->fragment->payload) { - dsp_processor_worker((void *)new_pcmChunk, (void *)scSet); + dsp_processor_worker(new_pcmChunk->fragment->payload, + new_pcmChunk->fragment->size / ((scSet->bits / 8) * scSet->ch), + scSet->sr, scSet->ch); } #endif @@ -917,19 +1012,6 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, pcmChunk.outData = NULL; pcmChunk.bytes = 0; - if (player_send_snapcast_setting(scSet) != pdPASS) { - ESP_LOGE(TAG, - "Failed to " - "notify " - "sync task " - "about " - "codec. Did you " - "init player?"); - - // critical error - esp_restart(); - } - break; } @@ -951,20 +1033,26 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, // "got PCM decoded chunk size: %ld // frames", scSet->chkInFrames); - if (player_send_snapcast_setting(scSet) != pdPASS) { - ESP_LOGE(TAG, - "Failed to notify " - "sync task about " - "codec. Did you " - "init player?"); - // critical error - esp_restart(); + if (chkInFrames != scSet->chkInFrames) { + if (player_send_snapcast_setting(scSet) != pdPASS) { + ESP_LOGE(TAG, + "Failed to notify " + "sync task about " + "codec. Did you " + "init player?"); + + // critical error + esp_restart(); + } + chkInFrames = scSet->chkInFrames; } #if CONFIG_USE_DSP_PROCESSOR if ((*pcmData) && ((*pcmData)->fragment->payload)) { - dsp_processor_worker((void *)(*pcmData), (void *)scSet); + dsp_processor_worker((*pcmData)->fragment->payload, + (*pcmData)->fragment->size / ((scSet->bits / 8) * scSet->ch), + scSet->sr, scSet->ch); } #endif if (*pcmData) { @@ -990,6 +1078,46 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, } } +void update_state(bool *received_wire_chnk, bool *playback, bool paused) { + static int64_t last = 0; + static snapclient_state_t state = IDLE; //Todo + if ((paused || state != PLAYING) && (!paused || state != PAUSED) && *received_wire_chnk) { + xSemaphoreTake(snapclientStateMux, portMAX_DELAY); + if (paused) { + sc_state = PAUSED; + *playback = false; + ESP_LOGI(TAG, "Set paused"); + }else{ + sc_state = PLAYING; + ESP_LOGI(TAG, "Set playing"); + *playback = true; + } + state = sc_state; + xSemaphoreGive(snapclientStateMux); + sc_call_state_cb(); + last = esp_timer_get_time(); + *received_wire_chnk = false; + } + else if (state == PLAYING || state == PAUSED) { + int64_t now = esp_timer_get_time(); + if (now-last > 1000000) { //update once per sec + if (!(*received_wire_chnk)) { + xSemaphoreTake(snapclientStateMux, portMAX_DELAY); + sc_state = IDLE; + *playback = false; + state = sc_state; + xSemaphoreGive(snapclientStateMux); + sc_call_state_cb(); + ESP_LOGI(TAG, "Set idle"); + } + last = now; + *received_wire_chnk = false; + } + } + +} + + /* * returns: * 0 if a message was (partially) processed sucessfully @@ -998,9 +1126,12 @@ void handle_chunk_message(codec_type_t codec, snapcastSetting_t *scSet, int process_data(snapcast_protocol_parser_t *parser, time_sync_data_t *time_sync_data, bool *received_codec_header, codec_type_t *codec, snapcastSetting_t *scSet, - pcm_chunk_message_t **pcmData) { + pcm_chunk_message_t **pcmData, bool *playback, bool paused) { base_message_t base_message_rx; + static bool received_wire_chnk = false; + update_state(&received_wire_chnk, playback, paused); + if (parse_base_message(parser, &base_message_rx) != PARSER_OK) { return -1; // restart connection } @@ -1012,9 +1143,9 @@ int process_data(snapcast_protocol_parser_t *parser, switch (base_message_rx.type) { case SNAPCAST_MESSAGE_WIRE_CHUNK: { wire_chunk_message_t wire_chnk = {{0, 0}, 0, NULL}; // is wire_chnk.payload ever used? - + received_wire_chnk = true; // skip this wires chunk message if codec header message was not received yet! - if (*received_codec_header == false) { + if (*received_codec_header == false || paused) { if (parser_skip_typed_message(parser, &base_message_rx) != PARSER_OK) { return -1; } @@ -1024,7 +1155,7 @@ int process_data(snapcast_protocol_parser_t *parser, if (parse_wire_chunk_message(parser, &base_message_rx, *codec, pcmData, &wire_chnk, &decoderChunk) != PARSER_OK) { return -1; } - handle_chunk_message(*codec, scSet, pcmData, &wire_chnk); + handle_chunk_message(*codec, &(scSet->playerSetting), pcmData, &wire_chnk); return 0; } @@ -1035,7 +1166,7 @@ int process_data(snapcast_protocol_parser_t *parser, if (parse_codec_header_message(parser, received_codec_header, codec, &codecPayload, &codecPayloadLen) != PARSER_OK) { return_value = -1; } else { - codec_header_received(codecPayload, codecPayloadLen, *codec, scSet, time_sync_data); + codec_header_received(codecPayload, codecPayloadLen, *codec, &(scSet->playerSetting), time_sync_data); } // in all cases: free Payload @@ -1051,7 +1182,7 @@ int process_data(snapcast_protocol_parser_t *parser, if (parse_sever_settings_message(parser, &base_message_rx, &server_settings_message) != PARSER_OK) { return -1; } - server_settings_msg_received(&server_settings_message, scSet); + server_settings_msg_received(&server_settings_message, scSet, *playback); return 0; } @@ -1068,6 +1199,8 @@ int process_data(snapcast_protocol_parser_t *parser, if (parser_skip_typed_message(parser, &base_message_rx) != PARSER_OK) { return -1; } + + ESP_LOGI(TAG, "done skipping typed message %d", base_message_rx.type); return 0; } } @@ -1118,6 +1251,9 @@ static void http_get_task(void *pvParameters) { codec_type_t codec = NONE; snapcastSetting_t scSet; pcm_chunk_message_t *pcmData = NULL; + uint32_t command = STOP; + bool paused = false; + bool playback = false; // create a timer to send time sync messages every x µs // esp_timer_create(&tSyncArgs, &time_sync_data.timeSyncMessageTimer); @@ -1162,6 +1298,22 @@ static void http_get_task(void *pvParameters) { } } + // block if state = STOPPED + xSemaphoreTake(snapclientStateMux, portMAX_DELAY); + if (sc_state == STOPPED) { + xSemaphoreGive(snapclientStateMux); + sc_call_state_cb(); // call callbacks here so we can be sure that netconn is closed. Player task could still be running. + command = STOP; + while(command != START) { + xTaskNotifyWait( 0, 0, &command, portMAX_DELAY); + } + xSemaphoreTake(snapclientStateMux, portMAX_DELAY); + } + sc_state = IDLE; + xSemaphoreGive(snapclientStateMux); + sc_call_state_cb(); + playback = false; + // NETWORK setup ends here ( or before getting mac address ) setup_network(&connection.netif); @@ -1257,13 +1409,11 @@ static void http_get_task(void *pvParameters) { hello_message_serialized = NULL; // init default setting - scSet.buf_ms = 500; - scSet.codec = NONE; - scSet.bits = 16; - scSet.ch = 2; - scSet.sr = 44100; - scSet.chkInFrames = 0; - scSet.volume = 0; + scSet.playerSetting.buf_ms = 0; + scSet.playerSetting.bits = 16; + scSet.playerSetting.ch = 2; + scSet.playerSetting.sr = 44100; + scSet.playerSetting.chkInFrames = 0; scSet.muted = true; snapcast_protocol_parser_t parser; @@ -1294,9 +1444,58 @@ static void http_get_task(void *pvParameters) { // Main connection loop - state machine + data processing while (1) { + bool restart = false; + static bool playback_old = false; + if (xTaskNotifyWait(0, 0, &command, 1) == pdTRUE) { + switch(command) { + case STOP: + stop_player_task(); // stop player task for faster teardown + xSemaphoreTake(snapclientStateMux, portMAX_DELAY); + sc_state = STOPPED; + xSemaphoreGive(snapclientStateMux); + // fall through to restart connection and wait for START command + case RESTART: + restart = true; + break; + case UNPAUSE: + paused = false; + break; + case PAUSE: + paused = true; + break; + default: + break; + } + //ESP_LOGI(TAG, "http got cb. %s", paused ? "paused" : "playing/idle"); + } + if (restart) { + //restart required + netconn_close(lwipNetconn); + netconn_delete(lwipNetconn); + lwipNetconn = NULL; + break; // restart connection + } + + if (playback_old != playback) { + if (playback) { + // need to apply settings when starting to play +#if SNAPCAST_USE_SOFT_VOL + if (!scSet.muted) { + dsp_processor_set_volome((double)scSet.volume / 100); + } else { + dsp_processor_set_volome(0.0); + } +#else + set_volume_cb(scSet.volume); +#endif + set_mute_state(scSet.muted); + } + playback_old = playback; + } + int result = process_data(&parser, &time_sync_data, &received_codec_header, &codec, - &scSet, &pcmData); + &scSet, &pcmData, &playback, paused); if (result != 0) { break; // restart connection } @@ -1307,38 +1506,108 @@ static void http_get_task(void *pvParameters) { /** * */ -static void dac_control_task(audio_board_handle_t board_handle, - QueueHandle_t audioQHdl) { - audioDACdata_t dac_data; - audioDACdata_t dac_data_old = { - .mute = true, +int init_snapclient(void (*set_volume)(int), void (*set_mute)(bool, bool), i2s_std_gpio_config_t i2s_pin_config0, i2s_port_t I2S_NUM_0, bool (*lock)(bool, TickType_t)) { + if (set_volume == NULL) { + ESP_LOGE(TAG, "Volume callback is NULL"); + + return -1; + } + if (set_mute == NULL) { + ESP_LOGE(TAG, "Mute callback is NULL"); + + return -1; + } + set_volume_cb = set_volume; + set_mute_cb = set_mute; + if (snapclientStateMux == NULL) { + snapclientStateMux = xSemaphoreCreateMutex(); + } + init_player(i2s_pin_config0, I2S_NUM_0, player_set_mute, on_player_state_paused, lock); + + xTaskCreatePinnedToCore(&http_get_task, "http", 15 * 1024, NULL, + HTTP_TASK_PRIORITY, &t_http_get_task, + HTTP_TASK_CORE_ID); + + return 0; +} + + +/** + * + */ +static void dac_control(audio_board_handle_t board_handle, + audioDACdata_t dac_data) { + static audioDACdata_t dac_data_old = { + .playerMute = true, + .stateMute = true, .volume = -1, - .enabled = false, }; + static bool muted = true; // TODO: can and should we pass audio_hal_handle_t instead of // audio_board_handle_t? - while (1) { - if (xQueueReceive(audioQHdl, &dac_data, portMAX_DELAY) == pdTRUE) { - if (dac_data.mute != dac_data_old.mute) { - audio_hal_set_mute(board_handle->audio_hal, dac_data.mute); - } - if (dac_data.volume != dac_data_old.volume) { - audio_hal_set_volume(board_handle->audio_hal, dac_data.volume); - } - if (dac_data.enabled != dac_data_old.enabled) { - if (dac_data.enabled) { - audio_hal_ctrl_codec(board_handle->audio_hal, - AUDIO_HAL_CODEC_MODE_DECODE, - AUDIO_HAL_CTRL_START); - } else { - audio_hal_ctrl_codec(board_handle->audio_hal, - AUDIO_HAL_CODEC_MODE_DECODE, - AUDIO_HAL_CTRL_STOP); - } - } - dac_data_old = dac_data; + if (dac_data.playerMute != dac_data_old.playerMute || + dac_data.stateMute != dac_data_old.stateMute) { + // if either player or state mute is active, we need to mute the output + bool mute = dac_data.playerMute || dac_data.stateMute; + if (mute != muted) { + muted = mute; + audio_hal_set_mute(board_handle->audio_hal, muted); } } + if (dac_data.volume != dac_data_old.volume) { + audio_hal_set_volume(board_handle->audio_hal, dac_data.volume); + } + dac_data_old = dac_data; +} + +/** + * Set mute state. If set_state is true, it reflects the snapclient state. Otherwise it + * is coming from player for temporary muting e.g. during startup. + */ +void audio_set_mute(bool mute, bool set_state) { + xSemaphoreTake(audioDACSemaphore, portMAX_DELAY); + if (set_state && (mute != audioDAC_data.stateMute)) { + audioDAC_data.stateMute = mute; + xQueueOverwrite(audioDACQHdl, &audioDAC_data); + } + else if (!set_state && mute != audioDAC_data.playerMute) { + audioDAC_data.playerMute = mute; + xQueueOverwrite(audioDACQHdl, &audioDAC_data); + } + xSemaphoreGive(audioDACSemaphore); +} + +/** + * + */ +void audio_set_volume(int volume) { + xSemaphoreTake(audioDACSemaphore, portMAX_DELAY); + if (volume != audioDAC_data.volume) { + audioDAC_data.volume = volume; + xQueueOverwrite(audioDACQHdl, &audioDAC_data); + } + xSemaphoreGive(audioDACSemaphore); +} +/** + * Callback for snapclient state changes (playing, paused, idle). Used to trigger actions on state changes, e.g. muting the audio output when paused or idle. + */ +void on_sc_state_changed() { + if (snapclientStateChangedMutex != NULL) { + xSemaphoreGive(snapclientStateChangedMutex); + } + ESP_LOGI(TAG, "main task cb"); +} + +bool i2s_lock(bool lock, TickType_t wait) { + if (i2sLockMutex == NULL) { + return false; + } + if (lock) { + return xSemaphoreTake(i2sLockMutex, wait); + } + else { + return xSemaphoreGive(i2sLockMutex); + } } /** @@ -1370,6 +1639,8 @@ void app_main(void) { esp_log_level_set("UI_HTTP", ESP_LOG_WARN); esp_log_level_set("dspProc", ESP_LOG_DEBUG); + t_main_task = xTaskGetCurrentTaskHandle(); + #if CONFIG_SNAPCLIENT_USE_INTERNAL_ETHERNET || \ CONFIG_SNAPCLIENT_USE_SPI_ETHERNET // clang-format off @@ -1501,10 +1772,25 @@ void app_main(void) { }, }; - QueueHandle_t audioQHdl = xQueueCreate(1, sizeof(audioDACdata_t)); + audioDACQHdl = xQueueCreate(1, sizeof(audioDACdata_t)); + audioDACSemaphore = xSemaphoreCreateMutex(); + audioDAC_data.stateMute = true; + audioDAC_data.playerMute = true; + audioDAC_data.volume = -1; + + i2sLockMutex = xSemaphoreCreateBinary(); + + init_snapclient(audio_set_volume, audio_set_mute, i2s_pin_config0, I2S_NUM_0, i2s_lock); + //init_player(i2s_pin_config0, I2S_NUM_0, player_set_mute); + sc_add_state_cb(on_sc_state_changed); + sc_add_state_cb(ota_on_sc_state_changed); - init_snapcast(audioQHdl); - init_player(i2s_pin_config0, I2S_NUM_0); + // Create binary semaphore for player state change notification + snapclientStateChangedMutex = xSemaphoreCreateBinary(); + if (snapclientStateChangedMutex == NULL) { + ESP_LOGE(TAG, "Failed to create snapclientStateChangedMutex"); + return; + } #if CONFIG_DAC_TAS5805M // Apply persisted TAS5805M settings now that the codec has been initialized @@ -1544,12 +1830,9 @@ void app_main(void) { dsp_settings_init(); // Then settings can restore params into the processor #endif - xTaskCreatePinnedToCore(&ota_server_task, "ota", 14 * 256, NULL, + xTaskCreatePinnedToCore(&ota_server_task, "ota", 15 * 256, NULL, OTA_TASK_PRIORITY, &t_ota_task, OTA_TASK_CORE_ID); - - xTaskCreatePinnedToCore(&http_get_task, "http", 15 * 1024, NULL, - HTTP_TASK_PRIORITY, &t_http_get_task, - HTTP_TASK_CORE_ID); + sc_start_snapclient(); // while (1) { // // audio_event_iface_msg_t msg; @@ -1576,6 +1859,28 @@ void app_main(void) { }; esp_pm_configure(&pmConfig); #endif - - dac_control_task(board_handle, audioQHdl); + audioDACdata_t dac_data; + snapclient_state_t state = IDLE; + while (1) { + if (xQueueReceive(audioDACQHdl, &dac_data, pdMS_TO_TICKS(90)) == pdTRUE) { + dac_control(board_handle, dac_data); + } + if (xSemaphoreTake(snapclientStateChangedMutex, pdMS_TO_TICKS(10)) == pdTRUE) { + snapclient_state_t state_new = sc_get_snapclient_state(); + ESP_LOGI(TAG, "main got cb: %d", state_new); + if (state_new != state) { + ESP_LOGI(TAG, "Player state changed: %d -> %d", state, state_new); + if (state_new == PLAYING) { + audio_hal_ctrl_codec(board_handle->audio_hal, + AUDIO_HAL_CODEC_MODE_DECODE, + AUDIO_HAL_CTRL_START); + } else if (state == PLAYING) { + audio_hal_ctrl_codec(board_handle->audio_hal, + AUDIO_HAL_CODEC_MODE_DECODE, + AUDIO_HAL_CTRL_STOP); + } + state = state_new; + } + } + } } diff --git a/sdkconfig.defaults b/sdkconfig.defaults index 0bd8708b..36cb5f63 100644 --- a/sdkconfig.defaults +++ b/sdkconfig.defaults @@ -37,6 +37,7 @@ CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_USE_TICKLESS_IDLE=y CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH=y +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 CONFIG_LOG_DEFAULT_LEVEL_NONE=y CONFIG_LOG_MAXIMUM_LEVEL_INFO=y CONFIG_LOG_COLORS=y diff --git a/sdkconfig_MAX98357A_ESP32-S2 b/sdkconfig_MAX98357A_ESP32-S2 index ce34fb16..21cb4484 100644 --- a/sdkconfig_MAX98357A_ESP32-S2 +++ b/sdkconfig_MAX98357A_ESP32-S2 @@ -1189,7 +1189,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set # end of Kernel diff --git a/sdkconfig_PCM5102A b/sdkconfig_PCM5102A index 445c1c00..31f2d89b 100644 --- a/sdkconfig_PCM5102A +++ b/sdkconfig_PCM5102A @@ -1135,7 +1135,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set CONFIG_FREERTOS_USE_TICKLESS_IDLE=y diff --git a/sdkconfig_PCM5102A_Olimex-ESP32-PoE b/sdkconfig_PCM5102A_Olimex-ESP32-PoE index 66d736c9..99f51da6 100644 --- a/sdkconfig_PCM5102A_Olimex-ESP32-PoE +++ b/sdkconfig_PCM5102A_Olimex-ESP32-PoE @@ -1251,7 +1251,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_USE_LIST_DATA_INTEGRITY_CHECK_BYTES is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set diff --git a/sdkconfig_PCM5102A_WT32-ETH01 b/sdkconfig_PCM5102A_WT32-ETH01 index c9703d00..80e9056f 100644 --- a/sdkconfig_PCM5102A_WT32-ETH01 +++ b/sdkconfig_PCM5102A_WT32-ETH01 @@ -1137,7 +1137,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set # end of Kernel diff --git a/sdkconfig_TAS5805M b/sdkconfig_TAS5805M index 347372a1..311993de 100644 --- a/sdkconfig_TAS5805M +++ b/sdkconfig_TAS5805M @@ -1214,7 +1214,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set CONFIG_FREERTOS_USE_TICKLESS_IDLE=y diff --git a/sdkconfig_adau1961 b/sdkconfig_adau1961 index 7786e673..3f980c39 100644 --- a/sdkconfig_adau1961 +++ b/sdkconfig_adau1961 @@ -1147,7 +1147,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set CONFIG_FREERTOS_USE_TICKLESS_IDLE=y diff --git a/sdkconfig_for_esp_snapserver b/sdkconfig_for_esp_snapserver index fdcc5d9b..0637c068 100644 --- a/sdkconfig_for_esp_snapserver +++ b/sdkconfig_for_esp_snapserver @@ -1097,7 +1097,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set # end of Kernel diff --git a/sdkconfig_lyrat_v4.3 b/sdkconfig_lyrat_v4.3 index bc7af6c5..a4003b15 100644 --- a/sdkconfig_lyrat_v4.3 +++ b/sdkconfig_lyrat_v4.3 @@ -1184,7 +1184,7 @@ CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=1536 CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=5 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 -CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set CONFIG_FREERTOS_USE_TICKLESS_IDLE=y