bugfix(esp_audio_render): Fixed mixer failed to restart

Author: TempoTian

packages/esp_audio_render/CHANGELOG.md

@@ -0,0 +1,22 @@
+## v0.7.1
+
+### Features
+
+- Added API `esp_audio_render_task_reconfigure` for reconfiguration of render task
+- Added `process_buf_align` to allow use special aligned buffer for audio processor
+- Added API `esp_audio_render_stream_set_mixer_gain` for changing of stream mixer gain
+- Added API `esp_audio_render_stream_set_fade` to do fade in/out when stream is mixing
+- Changed `ESP_AUDIO_RENDER_MIXER_THREAD_PRIORITY` default value to 20
+
+### Bug Fixes
+
+- Fixed double free caused by pipeline failed to create
+- Fixed mixer thread can not restart when all stream close and reopen
+- Warning for writing to ringfifo if timeout to prevent from resisting for further write
+
+
+## v0.7.0
+
+### Features
+
+- Initial version of `esp_audio_render`

packages/esp_audio_render/Kconfig

@@ -9,5 +9,5 @@ menu "Espressif Audio Render Configuration"
 
     config ESP_AUDIO_RENDER_MIXER_THREAD_PRIORITY
         int "Audio render mixer thread priority"
-        default 5
+        default 20
 endmenu

packages/esp_audio_render/idf_component.yml

@@ -1,4 +1,4 @@
-version: "0.7.0"
+version: "0.7.1"
 description: Espressif Audio Render is a module for render PCM audio through output device
 url: https://github.com/espressif/esp-gmf/tree/main/packages/esp_audio_render
 documentation: "https://github.com/espressif/esp-gmf/blob/main/packages/esp_audio_render/README.md"

packages/esp_audio_render/include/esp_audio_render.h

@@ -9,6 +9,7 @@
 
 #include "esp_audio_render_types.h"
 #include "esp_gmf_element.h"
+#include "esp_gmf_task.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -18,17 +19,19 @@ extern "C" {
  * @brief  Audio render configuration
  */
 typedef struct {
-    uint8_t                          max_stream_num;   /*!< Maximum supported stream number */
-    esp_audio_render_write_cb_t      out_writer;       /*!< Audio render write callback */
-    void                            *out_ctx;          /*!< Audio render write context */
-    esp_audio_render_sample_info_t   out_sample_info;  /*!< Output sample information, needs to be aligned with actual device setting */
-    void                            *pool;             /*!< GMF pool handle */
+    uint8_t                          max_stream_num;    /*!< Maximum supported stream number */
+    esp_audio_render_write_cb_t      out_writer;        /*!< Audio render write callback */
+    void                            *out_ctx;           /*!< Audio render write context */
+    esp_audio_render_sample_info_t   out_sample_info;   /*!< Output sample information, needs to be aligned with actual device setting */
+    void                            *pool;              /*!< GMF pool handle */
     uint16_t                         process_period;    /*!< Audio processing interval in milliseconds (default: 20ms)
                                                              This determines how frequently the audio mixer processes input streams
                                                              Only valid for multiple streams which need mix processor
                                                              - Shorter periods: Faster audio response but require more precise timing
                                                              - Longer periods: More tolerant to buffer variations but increase latency
                                                              This value controls the ring_fifo size used by `esp_audio_render_stream_write` also */
+    uint8_t                          process_buf_align; /*!< When use hardware or optimized processor may need special buffer alignment
+                                                             If set to 0, the default value is 16 */
 } esp_audio_render_cfg_t;
 
 /**
@@ -90,6 +93,25 @@ typedef int (*esp_audio_render_event_cb_t)(esp_audio_render_event_type_t event_t
  */
 esp_audio_render_err_t esp_audio_render_create(esp_audio_render_cfg_t *cfg, esp_audio_render_handle_t *render);
 
+/**
+ * @brief  Reconfigures the audio render task parameters
+ *
+ * @note  This function must be called when no audio stream is active (no stream is opened yet)
+ *
+ * @note  Default configuration (applied if never called):
+ *          - `stack_in_ext` = true (task stack allocated in external SPI-RAM)
+ *          - Other parameters use values from Kconfig defaults
+ *
+ * @param[in]  render  Audio render handle
+ * @param[in]  cfg     Pointer to task configuration
+ *
+ * @return
+ *       - ESP_AUDIO_RENDER_ERR_OK             On success
+ *       - ESP_AUDIO_RENDER_ERR_INVALID_ARG    Invalid input argument
+ *       - ESP_AUDIO_RENDER_ERR_INVALID_STATE  Called when any stream is opened
+ */
+esp_audio_render_err_t esp_audio_render_task_reconfigure(esp_audio_render_handle_t render, esp_gmf_task_config_t *cfg);
+
 /**
  * @brief  Set event callback for audio render
  *
@@ -182,6 +204,24 @@ esp_audio_render_err_t esp_audio_render_stream_get(esp_audio_render_handle_t ren
                                                    esp_audio_render_stream_id_t stream_id,
                                                    esp_audio_render_stream_handle_t *stream_handle);
 
+/**
+ * @brief  Set mixer gain for audio render stream (optional)
+ *
+ * @note  Currently only support to set when none stream is opened yet
+ *        When this API not call it will use default mixer gain [0, sqrt(1.0 / max_stream_num)]
+ *        Target gain should be limited to avoid clipping after mixed
+ *
+ * @param[in]   stream         Audio render handle
+ * @param[in]   mixer_gain     Mixer gain to set
+ *
+ * @return
+ *       - ESP_AUDIO_RENDER_ERR_OK             On success
+ *       - ESP_AUDIO_RENDER_ERR_INVALID_ARG    Invalid input argument
+ *       - ESP_AUDIO_RENDER_ERR_INVALID_STATE  Mixer already running
+ */
+esp_audio_render_err_t esp_audio_render_stream_set_mixer_gain(esp_audio_render_stream_handle_t stream,
+                                                              esp_audio_render_mixer_gain_t *mixer_gain);
+
 /**
  * @brief  Open audio render stream
  *
@@ -254,6 +294,24 @@ esp_audio_render_err_t esp_audio_render_stream_get_element(esp_audio_render_stre
 esp_audio_render_err_t esp_audio_render_stream_write(esp_audio_render_stream_handle_t stream,
                                                      uint8_t *pcm_data, uint32_t pcm_size);
 
+ /**
+ * @brief  Fade in/out for audio render stream
+ *
+ * @note  Fade in/out will only take effect in multiple stream cases
+ *        When fade in, mixer gain for this stream will goes from current to target gain
+ *        When fade out, mixer gain for this stream will goes from current to initial gain
+ *        Allow to set during runtime
+ *
+ * @param[in]  stream   Stream handle
+ * @param[in]  fade_in  Fade operation (true: fade in, false: fade out)
+ *
+ * @return
+ *       - ESP_AUDIO_RENDER_ERR_OK             On success
+ *       - ESP_AUDIO_RENDER_ERR_INVALID_ARG    Invalid input argument
+ */
+esp_audio_render_err_t esp_audio_render_stream_set_fade(esp_audio_render_stream_handle_t stream,
+                                                        bool fade_in);
+
 /**
  * @brief  Pause audio render stream
  *

packages/esp_audio_render/include/esp_audio_render_types.h

@@ -55,6 +55,15 @@ typedef struct {
     uint8_t   channel;          /*!< Audio channel */
 } esp_audio_render_sample_info_t;
 
+/**
+ * @brief  Audio render mixer gain
+ */
+typedef struct {
+    float     initial_gain;     /*!< Initial gain for mixer stream */
+    float     target_gain;      /*!< Target gain for mixer stream */
+    uint32_t  transition_time;  /*!< Transition time to smooth from initial to target or versa (unit ms) */
+} esp_audio_render_mixer_gain_t;
+
 /**
  * @brief  Audio render writer callback
  *

packages/esp_audio_render/private_inc/audio_render_proc.h

@@ -15,6 +15,9 @@
 extern "C" {
 #endif  /* __cplusplus */
 
+#define SAME_SAMPLE_INFO(from, to) \
+    ((from).sample_rate == (to).sample_rate && (from).bits_per_sample == (to).bits_per_sample && (from).channel == (to).channel)
+
 /**
  * @brief  Audio render processor handle
  */
@@ -33,6 +36,19 @@ typedef void *audio_render_proc_handle_t;
  */
 esp_audio_render_err_t audio_render_proc_create(esp_gmf_pool_handle_t pool, audio_render_proc_handle_t *proc);
 
+/**
+ * @brief  Set buffer alignment for audio render processor
+ *
+ * @param[in]  proc       Audio processor handle
+ * @param[in]  buf_align  Audio render processor handle to store
+ *
+ * @return
+ *       - ESP_AUDIO_RENDER_ERR_OK           On success
+ *       - ESP_AUDIO_RENDER_ERR_INVALID_ARG  Invalid input argument
+ *       - ESP_AUDIO_RENDER_ERR_NO_MEM       Not enough memory
+ */
+esp_audio_render_err_t audio_render_proc_set_buf_align(audio_render_proc_handle_t proc, uint8_t buf_align);
+
 /**
  * @brief  Add audio processor
  *

packages/esp_audio_render/src/audio_render_pipeline.c

@@ -25,7 +25,7 @@ static inline void add_proc(const char *pipeline_tag[], const char *proc_tag, ui
     uint8_t n = *element_num;
     // Not add duplicate one
     for (int i = 0; i < n; i++) {
-        if (pipeline_tag[i] == proc_tag) {
+        if (strcmp(pipeline_tag[i], proc_tag) == 0) {
             return;
         }
     }
@@ -312,6 +312,12 @@ esp_audio_render_err_t audio_render_pipeline_open(audio_render_pipeline_cfg_t *p
                                         pipeline);
     if (ret != ESP_GMF_ERR_OK) {
         ESP_LOGE(TAG, "Failed to new pipeline ret %d", ret);
+        if (proc_cfg->in_port) {
+            esp_gmf_port_deinit(proc_cfg->in_port);
+        }
+        if (proc_cfg->out_port) {
+            esp_gmf_port_deinit(proc_cfg->out_port);
+        }
         return ESP_AUDIO_RENDER_ERR_NO_RESOURCE;
     }
     esp_gmf_element_handle_t head_element = ESP_GMF_PIPELINE_GET_FIRST_ELEMENT((*pipeline));

packages/esp_audio_render/src/audio_render_proc.c

@@ -14,14 +14,12 @@
 
 #define TAG "AUD_RENDER_PROC"
 
-#define SAME_SAMPLE_INFO(from, to) \
-    ((from).sample_rate == (to).sample_rate && (from).bits_per_sample == (to).bits_per_sample && (from).channel == (to).channel)
-
 typedef struct {
     esp_gmf_pool_handle_t          pool;
     esp_audio_render_proc_type_t  *procs;
     esp_gmf_element_handle_t      *proc_elements;
     uint8_t                        proc_num;
+    uint8_t                        buf_align;
     esp_gmf_pipeline_handle_t      pipeline;
     bool                           is_opened;
     bool                           is_error;
@@ -80,6 +78,18 @@ static esp_gmf_err_io_t sink_acquire(void *handle, esp_gmf_payload_t *load, uint
         return ESP_GMF_IO_OK;
     }
     if (proc->out_pcm_size < wanted_size) {
+        if (proc->buf_align) {
+            if (proc->out_pcm) {
+                audio_render_free(proc->out_pcm);
+                proc->out_pcm_size = 0;
+            }
+            proc->out_pcm = audio_render_malloc_align(wanted_size, proc->buf_align);
+            if (proc->out_pcm == NULL) {
+                // Not enough memory
+                return ESP_GMF_IO_FAIL;
+            }
+            proc->out_pcm_size = wanted_size;
+        }
         uint8_t *out_pcm = audio_render_realloc(proc->out_pcm, wanted_size);
         if (out_pcm == NULL) {
             // Not enough memory
@@ -167,6 +177,17 @@ esp_audio_render_err_t audio_render_proc_create(esp_gmf_pool_handle_t pool, audi
     return ESP_AUDIO_RENDER_ERR_OK;
 }
 
+esp_audio_render_err_t audio_render_proc_set_buf_align(audio_render_proc_handle_t handle, uint8_t buf_align)
+{
+    if (handle == NULL) {
+        ESP_LOGE(TAG, "Invalid arg for handle:%p", handle);
+        return ESP_AUDIO_RENDER_ERR_INVALID_ARG;
+    }
+    audio_proc_t *proc = (audio_proc_t*)handle;
+    proc->buf_align = buf_align;
+    return ESP_AUDIO_RENDER_ERR_OK;
+}
+
 esp_audio_render_err_t audio_render_proc_add(audio_render_proc_handle_t handle, esp_audio_render_proc_type_t *procs,
                                              uint8_t proc_num)
 {
@@ -235,6 +256,12 @@ esp_audio_render_err_t audio_render_proc_open(audio_render_proc_handle_t handle,
             out_port = NEW_ESP_GMF_PORT_OUT_BLOCK(sink_acquire, sink_release, NULL, proc, 0, ESP_GMF_MAX_DELAY);
             if (in_port == NULL || out_port == NULL) {
                 ESP_LOGE(TAG, "Fail to create port");
+                if (in_port) {
+                    esp_gmf_port_deinit(in_port);
+                }
+                if (out_port) {
+                    esp_gmf_port_deinit(out_port);
+                }
                 break;
             }
             audio_render_pipeline_cfg_t pipeline_cfg = {
@@ -246,6 +273,7 @@ esp_audio_render_err_t audio_render_proc_open(audio_render_proc_handle_t handle,
                 .proc_elements = proc->proc_elements,
                 .proc_num = proc->proc_num,
             };
+            // When create pipeline success port will takeover by pipeline
             ret = audio_render_pipeline_open(&pipeline_cfg, &proc->pipeline);
             if (ret != ESP_AUDIO_RENDER_ERR_OK) {
                 ESP_LOGE(TAG, "Fail to create pipeline");
@@ -258,12 +286,6 @@ esp_audio_render_err_t audio_render_proc_open(audio_render_proc_handle_t handle,
         proc->is_opened = true;
         return ret;
     } while (0);
-    if (in_port) {
-        esp_gmf_port_deinit(in_port);
-    }
-    if (out_port) {
-        esp_gmf_port_deinit(out_port);
-    }
     audio_render_proc_close((audio_render_proc_handle_t) proc);
     return ESP_AUDIO_RENDER_ERR_NO_RESOURCE;
 }