text: /* Play mp3 file by audio pipeline
     with possibility to start, stop, pause and resume playback
     as well as adjust volume
  
     This example code is in the Public Domain (or CC0 licensed, at your option.)
  
     Unless required by applicable law or agreed to in writing, this
     software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
     CONDITIONS OF ANY KIND, either express or implied.
  */
  
  #include <string.h>
  #include "freertos/FreeRTOS.h"
  #include "freertos/task.h"
  
  #include "esp_log.h"
  #include "audio_element.h"
  #include "audio_pipeline.h"
  #include "audio_event_iface.h"
  #include "audio_mem.h"
  #include "audio_common.h"
  #include "i2s_stream.h"
  #include "mp3_decoder.h"
  #include "esp_peripherals.h"
  #include "periph_touch.h"
  #include "audio_hal.h"
  #include "board.h"
  
  static const char *TAG = "PLAY_MP3_FLASH";
  
  /*
     To embed it in the app binary, the mp3 file is named
     in the component.mk COMPONENT_EMBED_TXTFILES variable.
  */
  extern const uint8_t adf_music_mp3_start[] asm("_binary_adf_music_mp3_start");
  extern const uint8_t adf_music_mp3_end[]   asm("_binary_adf_music_mp3_end");
  static int adf_music_mp3_pos;
  
  int mp3_music_read_cb(audio_element_handle_t el, char *buf, int len, TickType_t wait_time, void *ctx)
  {
      int read_size = adf_music_mp3_end - adf_music_mp3_start - adf_music_mp3_pos;
      if (read_size == 0) {
          return AEL_IO_DONE;
      } else if (len < read_size) {
          read_size = len;
      }
      memcpy(buf, adf_music_mp3_start + adf_music_mp3_pos, read_size);
      adf_music_mp3_pos += read_size;
      return read_size;
  }
  
  void app_main(void)
  {
      audio_pipeline_handle_t pipeline;
      audio_element_handle_t i2s_stream_writer, mp3_decoder;
  
      esp_log_level_set("*", ESP_LOG_WARN);
      esp_log_level_set(TAG, ESP_LOG_INFO);
  
      ESP_LOGI(TAG, "[ 1 ] Start audio codec chip");
      audio_hal_codec_config_t audio_hal_codec_cfg =  AUDIO_HAL_ES8388_DEFAULT();
      audio_hal_handle_t hal = audio_hal_init(&audio_hal_codec_cfg, 0);
      audio_hal_ctrl_codec(hal, AUDIO_HAL_CODEC_MODE_DECODE, AUDIO_HAL_CTRL_START);
      int player_volume;
      audio_hal_get_volume(hal, &player_volume);
  
      ESP_LOGI(TAG, "[ 2 ] Create audio pipeline, add all elements to pipeline, and subscribe pipeline event");
      audio_pipeline_cfg_t pipeline_cfg = DEFAULT_AUDIO_PIPELINE_CONFIG();
      pipeline = audio_pipeline_init(&pipeline_cfg);
      mem_assert(pipeline);
  
      ESP_LOGI(TAG, "[2.1] Create mp3 decoder to decode mp3 file and set custom read callback");
      mp3_decoder_cfg_t mp3_cfg = DEFAULT_MP3_DECODER_CONFIG();
      mp3_decoder = mp3_decoder_init(&mp3_cfg);
      audio_element_set_read_cb(mp3_decoder, mp3_music_read_cb, NULL);
  
      ESP_LOGI(TAG, "[2.2] Create i2s stream to write data to codec chip");
      i2s_stream_cfg_t i2s_cfg = I2S_STREAM_CFG_DEFAULT();
      i2s_cfg.type = AUDIO_STREAM_WRITER;
      i2s_stream_writer = i2s_stream_init(&i2s_cfg);
  
      ESP_LOGI(TAG, "[2.3] Register all elements to audio pipeline");
      audio_pipeline_register(pipeline, mp3_decoder, "mp3");
      audio_pipeline_register(pipeline, i2s_stream_writer, "i2s");
  
      ESP_LOGI(TAG, "[2.4] Link it together [mp3_music_read_cb]-->mp3_decoder-->i2s_stream-->[codec_chip]");
      audio_pipeline_link(pipeline, (const char *[]) {"mp3", "i2s"}, 2);
  
      ESP_LOGI(TAG, "[ 3 ] Initialize peripherals");
      esp_periph_config_t periph_cfg = { 0 };
      esp_periph_init(&periph_cfg);
  
      ESP_LOGI(TAG, "[3.1] Initialize Touch peripheral");
      periph_touch_cfg_t touch_cfg = {
          .touch_mask = TOUCH_SEL_SET | TOUCH_SEL_PLAY | TOUCH_SEL_VOLUP | TOUCH_SEL_VOLDWN,
          .tap_threshold_percent = 70,
      };
      esp_periph_handle_t touch_periph = periph_touch_init(&touch_cfg);
  
      ESP_LOGI(TAG, "[3.2] Start all peripherals");
      esp_periph_start(touch_periph);
  
      ESP_LOGI(TAG, "[ 4 ] Setup event listener");
      audio_event_iface_cfg_t evt_cfg = AUDIO_EVENT_IFACE_DEFAULT_CFG();
      audio_event_iface_handle_t evt = audio_event_iface_init(&evt_cfg);
  
      ESP_LOGI(TAG, "[4.1] Listening event from all elements of pipeline");
      audio_pipeline_set_listener(pipeline, evt);
  
      ESP_LOGI(TAG, "[4.2] Listening event from peripherals");
      audio_event_iface_set_listener(esp_periph_get_event_iface(), evt);
  
      ESP_LOGW(TAG, "[ 5 ] Tap touch buttons to control music player:");
      ESP_LOGW(TAG, "      [Play] to start, pause and resume, [Set] to stop.");
      ESP_LOGW(TAG, "      [Vol-] or [Vol+] to adjust volume.");
  
      while (1) {
          audio_event_iface_msg_t msg;
          esp_err_t ret = audio_event_iface_listen(evt, &msg, portMAX_DELAY);
          if (ret != ESP_OK) {
              ESP_LOGE(TAG, "[ * ] Event interface error : %d", ret); 
              continue;
          }
  
          if (msg.source_type == AUDIO_ELEMENT_TYPE_ELEMENT && msg.source == (void *) mp3_decoder
              && msg.cmd == AEL_MSG_CMD_REPORT_MUSIC_INFO) {
              audio_element_info_t music_info = {0};
              audio_element_getinfo(mp3_decoder, &music_info);
  
              ESP_LOGI(TAG, "[ * ] Receive music info from mp3 decoder, sample_rates=%d, bits=%d, ch=%d",
                  music_info.sample_rates, music_info.bits, music_info.channels);
  
              audio_element_setinfo(i2s_stream_writer, &music_info);
              i2s_stream_set_clk(i2s_stream_writer, music_info.sample_rates, music_info.bits, music_info.channels);
              continue;
          }
  
          if (msg.source_type == PERIPH_ID_TOUCH
                  && msg.cmd == PERIPH_TOUCH_TAP
                  && msg.source == (void *)touch_periph) {
  
              if ((int) msg.data == TOUCH_PLAY) {
                  ESP_LOGI(TAG, "[ * ] [Play] touch tap event");
                  audio_element_state_t el_state = audio_element_get_state(i2s_stream_writer);
                  switch (el_state) {
                     case AEL_STATE_INIT :
                         ESP_LOGI(TAG, "[ * ] Starting audio pipeline");
                         audio_pipeline_run(pipeline);
                         break;
                     case AEL_STATE_RUNNING :
                         ESP_LOGI(TAG, "[ * ] Pausing audio pipeline");
                         audio_pipeline_pause(pipeline);
                         break;
                     case AEL_STATE_PAUSED :
                         ESP_LOGI(TAG, "[ * ] Resuming audio pipeline");
                         audio_pipeline_resume(pipeline);
                         break;
                     case AEL_STATE_FINISHED :
                         ESP_LOGI(TAG, "[ * ] Rewinding audio pipeline");
                         audio_pipeline_stop(pipeline);
                         adf_music_mp3_pos = 0;
                         audio_pipeline_resume(pipeline);
                         break;
                     default :
                         ESP_LOGI(TAG, "[ * ] Not supported state %d", el_state);
                  }
              } else if ((int) msg.data == TOUCH_SET) {
                  ESP_LOGI(TAG, "[ * ] [Set] touch tap event");
                  ESP_LOGI(TAG, "[ * ] Stopping audio pipeline");
                  break;
              } else if ((int) msg.data == TOUCH_VOLUP) {
                  ESP_LOGI(TAG, "[ * ] [Vol+] touch tap event");
                  player_volume += 10;
                  if (player_volume > 100) {
                      player_volume = 100;
                  }
                  audio_hal_set_volume(hal, player_volume);
                  ESP_LOGI(TAG, "[ * ] Volume set to %d %%", player_volume);
              } else if ((int) msg.data == TOUCH_VOLDWN) {
                  ESP_LOGI(TAG, "[ * ] [Vol-] touch tap event");
                  player_volume -= 10;
                  if (player_volume < 0) {
                      player_volume = 0;
                  }
                  audio_hal_set_volume(hal, player_volume);
                  ESP_LOGI(TAG, "[ * ] Volume set to %d %%", player_volume);
              }
          }
      }
  
      ESP_LOGI(TAG, "[ 6 ] Stop audio_pipeline");
      audio_pipeline_terminate(pipeline);
  
      /* Terminate the pipeline before removing the listener */
      audio_pipeline_remove_listener(pipeline);
  
      /* Make sure audio_pipeline_remove_listener is called before destroying event_iface */
      audio_event_iface_destroy(evt);
  
      /* Release all resources */
      audio_pipeline_deinit(pipeline);
      audio_element_deinit(i2s_stream_writer);
      audio_element_deinit(mp3_decoder);
  }
  