Add SDCardPlayMP3 example, helix_mp3_drv and update AmebaFatFSFile (Ameba-AIoT#277)

TristonKF · web-flow · commit adbff26c110f · 2024-11-06T14:36:52.000+08:00
* Add SDCardPlayMP3 example, helix_mp3_drv and update AmebaFatFSFile Feature: - Add Example SDCardPlayMP3 - Add audio.mp3 API Updates: - Update AmebaFatFSFile.cpp and Update AmebaFatFSFile.h - Add helix_mp3_drv.c and Update helix_mp3_drv.h * Update platform.txt Update platform.txt for new include path. * Update Ameba-AIoT#277 commit Features -change play MP3 example guide to multimedia/example folder. -change helix_mp3_drv.c and .h to multimedia/src folder. -update platform.txt. * Deleted helix_mp3_drv.c and .h Feature Deleted helix_mp3_drv.c and .h from core folder * update Ameba-AIoT#277 -Change file location for sample mp3 to Ameba_misc\Example_Samples folder. -update docs links in SDCardPlayMP3.ino and UVCDObjectDetectionLoop.ino.
diff --git a/Ameba_misc/Example_Samples/Audio_test.mp3 b/Ameba_misc/Example_Samples/Audio_test.mp3
diff --git a/Arduino_package/hardware/libraries/FileSystem/src/AmebaFatFSFile.cpp b/Arduino_package/hardware/libraries/FileSystem/src/AmebaFatFSFile.cpp
@@ -1,6 +1,11 @@
 #include "Arduino.h"
 #include "AmebaFatFSFile.h"
 
+#ifdef __cplusplus
+extern "C" {
+#include "helix_mp3_drv.h"
+}
+#endif
 File::File(void)
 {
     _file = NULL;
@@ -15,15 +20,20 @@ File::File(const char *filename)
 bool File::open(const char *filename)
 {
     FRESULT res = FR_OK;
-
+    const char *extension = strrchr(filename, '.');
     _file = (FIL *)malloc(sizeof(FIL));
     if (_file == NULL) {
         res = FR_INT_ERR;
         printf("\r\n[ERROR] open file (%s) malloc fail.\n", filename);
         return false;
     }
 
-    res = f_open(_file, filename, FA_OPEN_ALWAYS | FA_READ | FA_WRITE);
+    if (strcmp(extension, ".mp3") == 0) {
+        res = f_open(_file, filename, FA_OPEN_EXISTING | FA_READ);
+        convertMp3ToArray();
+    } else {
+        res = f_open(_file, filename, FA_OPEN_ALWAYS | FA_READ | FA_WRITE);
+    }
 
     if (res != FR_OK) {
         printf("\r\n[ERROR] open file (%s) fail. (res=%d)\n", filename, res);
@@ -189,3 +199,55 @@ const char *File::name(void)
     }
     return NULL;
 }
+
+void File::convertMp3ToArray(void)
+{
+    uint32_t mp3_size = 0;
+    unsigned char *mp3_data = NULL;
+
+    if (_file != NULL) {
+        // Read ID3 header
+        unsigned char id3_header[10];
+        f_lseek(_file, 0);    // Move to the beginning
+        UINT bytesRead;
+        FRESULT res = f_read(_file, id3_header, 10, &bytesRead);
+
+        if (res != FR_OK || bytesRead != 10) {
+            printf("\r\n[ERROR] Failed to read ID3v2 header. (res=%d)\n", res);
+            return;
+        }
+
+        // Check for ID3v2
+        if (id3_header[0] == 'I' && id3_header[1] == 'D' && id3_header[2] == '3') {
+            uint32_t id3v2_size = ((id3_header[6] & 0x7F) << 21) | ((id3_header[7] & 0x7F) << 14) | ((id3_header[8] & 0x7F) << 7) | (id3_header[9] & 0x7F);
+            f_lseek(_file, id3v2_size + 10);    // Move past ID3v2
+        } else {
+            f_lseek(_file, 0);
+        }
+
+        // Calculate MP3 size
+        mp3_size = f_size(_file) - f_tell(_file);
+
+
+        // Allocate memory for MP3 data
+        mp3_data = (unsigned char *)malloc(mp3_size);
+        if (mp3_data == NULL) {
+            printf("\r\n[ERROR] Memory allocation failed for MP3 data.\n");
+            return;
+        }
+
+        // Read MP3 data
+        res = f_read(_file, mp3_data, mp3_size, &bytesRead);
+
+        if (res != FR_OK || bytesRead != mp3_size) {
+            printf("\r\n[ERROR] Failed to read MP3 data. (res=%d, bytesRead=%lu)\n", res, bytesRead);
+            free(mp3_data);
+            return;
+        }
+        audio_play_binary_array(mp3_data, mp3_size);
+        free(mp3_data);
+        mp3_data = NULL;
+    } else {
+        printf("\r\n[ERROR] No file opened to convert.\n");
+    }
+}
diff --git a/Arduino_package/hardware/libraries/FileSystem/src/AmebaFatFSFile.h b/Arduino_package/hardware/libraries/FileSystem/src/AmebaFatFSFile.h
@@ -35,6 +35,8 @@ class File: public Stream {
     bool isOpen(void);
     const char *name(void);
 
+    void convertMp3ToArray(void);
+
     friend class AmebaFatFS;
 
 private:
diff --git a/Arduino_package/hardware/libraries/Multimedia/examples/SDCardPlayMP3/SDCardPlayMP3.ino b/Arduino_package/hardware/libraries/Multimedia/examples/SDCardPlayMP3/SDCardPlayMP3.ino
@@ -0,0 +1,28 @@
+/*  This example decodes an MP3 file from an SD card
+    and plays audio through a TRRS 3.5mm audio jack module.
+
+ Example guide: https://ameba-doc-arduino-sdk.readthedocs-hosted.com/en/latest/amebapro2/Example_Guides/Multimedia/Play%20MP3%20with%20SD%20card.html
+
+*/
+#include "AmebaFatFS.h"
+
+#define FILENAME "Audio_test"
+#define INTERVAL 1000
+
+AmebaFatFS fs;
+
+void setup()
+{
+    Serial.begin(115200);
+
+    fs.begin();
+
+    File file = fs.open(String(fs.getRootPath()) + String(FILENAME) + String(".mp3"));
+
+    file.close();
+}
+
+void loop()
+{
+    delay(INTERVAL);
+}
diff --git a/Arduino_package/hardware/libraries/Multimedia/src/helix_mp3_drv.c b/Arduino_package/hardware/libraries/Multimedia/src/helix_mp3_drv.c
@@ -0,0 +1,169 @@
+#include "mp3dec.h"
+#include "audio_api.h"
+#include "helix_mp3_drv.h"
+#define MP3_MAX_FRAME_SIZE        (1600)
+#define BUFFER_SIZE               (1500)
+#define AUDIO_DMA_PAGE_SIZE       (2304)
+#define I2S_DMA_PAGE_SIZE         2304
+#define MP3_DATA_CACHE_SIZE       (BUFFER_SIZE + 2 * MP3_MAX_FRAME_SIZE)
+#define TX_PAGE_SIZE              AUDIO_DMA_PAGE_SIZE    // 64*N bytes, max: 4095. 128, 4032
+#define TX_PAGE_NUM               AUDIO_DMA_PAGE_NUM
+#define RX_PAGE_SIZE              AUDIO_DMA_PAGE_SIZE    // 64*N bytes, max: 4095. 128, 4032
+#define RX_PAGE_NUM               AUDIO_DMA_PAGE_NUM
+#define AUDIO_DMA_PAGE_NUM        4
+#define AUDIO_PKT_QUEUE_LENGTH    (50)
+#define AUDIO_TX_PCM_QUEUE_LENGTH (10)
+static uint32_t audio_tx_pcm_cache_len = 0;
+static int16_t audio_tx_pcm_cache[AUDIO_DMA_PAGE_SIZE * 3 / 4];
+
+#ifndef SDRAM_BSS_SECTION
+#define SDRAM_BSS_SECTION
+SECTION(".sdram.bss")
+#endif
+static xQueueHandle audio_tx_pcm_queue = NULL;
+SDRAM_BSS_SECTION static uint8_t decodebuf[8192];
+static audio_t g_taudio;
+static uint8_t dma_txdata[TX_PAGE_SIZE * TX_PAGE_NUM] __attribute__((aligned(0x20)));
+static uint8_t dma_rxdata[RX_PAGE_SIZE * RX_PAGE_NUM] __attribute__((aligned(0x20)));
+
+
+void audio_play_binary_array(uint8_t *srcbuf, uint32_t len)
+{
+    uint8_t *inbuf;
+    int bytesLeft;
+
+    int ret;
+    HMP3Decoder hMP3Decoder;
+    MP3FrameInfo frameInfo;
+
+    uint8_t first_frame = 1;
+    int ch_sel = 0;
+    short *wTemp;
+    audio_tx_pcm_queue = xQueueCreate(AUDIO_TX_PCM_QUEUE_LENGTH, AUDIO_DMA_PAGE_SIZE);
+    hMP3Decoder = MP3InitDecoder();
+    MP3DecodeSetChannel(ch_sel);
+
+    inbuf = srcbuf;
+    bytesLeft = len;
+    while (bytesLeft > 0) {
+        if (bytesLeft > 6) {
+            ret = MP3Decode(hMP3Decoder, &inbuf, &bytesLeft, (short *)decodebuf, 0);
+            wTemp = (short *)decodebuf;
+        } else {
+            ret = ERR_MP3_INDATA_UNDERFLOW;
+        }
+        if (!ret) {
+            MP3GetLastFrameInfo(hMP3Decoder, &frameInfo);
+            wTemp = (short *)decodebuf;
+            if (frameInfo.nChans == 2) {
+                for (int i = 0; i < 2048; i++) {
+                    wTemp[i] = wTemp[2 * i + ch_sel % 2];
+                }
+                frameInfo.outputSamps /= 2;
+            }
+
+            if (first_frame) {
+                initialize_audio(frameInfo.samprate);
+                first_frame = 0;
+            }
+            audio_play_pcm((int16_t *)decodebuf, frameInfo.outputSamps);
+        } else {
+            if (ret != ERR_MP3_INDATA_UNDERFLOW) {
+                printf("[ERROR] %d\r\n", ret);
+            }
+            break;
+        }
+    }
+
+    printf("decoding finished\r\n");
+}
+
+void initialize_audio(int sample_rate)
+{
+    uint8_t smpl_rate_idx = ASR_16KHZ;
+    // audio_sr smpl_rate_idx = ASR_16KHZ;
+
+    switch (sample_rate) {
+        case 8000:
+            smpl_rate_idx = ASR_8KHZ;
+            break;
+        case 16000:
+            smpl_rate_idx = ASR_16KHZ;
+            break;
+        case 32000:
+            smpl_rate_idx = ASR_32KHZ;
+            break;
+        case 44100:
+            smpl_rate_idx = ASR_44p1KHZ;
+            break;
+        case 48000:
+            smpl_rate_idx = ASR_48KHZ;
+            break;
+        case 88200:
+            smpl_rate_idx = ASR_88p2KHZ;
+            break;
+        case 96000:
+            smpl_rate_idx = ASR_96KHZ;
+            break;
+        default:
+            break;
+    }
+
+    audio_init(&g_taudio, OUTPUT_SINGLE_EDNED, MIC_SINGLE_EDNED, AUDIO_CODEC_2p8V);
+    audio_dac_digital_vol(&g_taudio, 0xAF / 2);
+
+    // Init TX dma
+
+    audio_set_dma_buffer(&g_taudio, dma_txdata, dma_rxdata, AUDIO_DMA_PAGE_SIZE, AUDIO_DMA_PAGE_NUM);
+
+
+    audio_rx_irq_handler(&g_taudio, (audio_irq_handler)audio_rx_complete, (uint32_t *)&g_taudio);
+
+    // Init TX dma
+    audio_tx_irq_handler(&g_taudio, (audio_irq_handler)audio_tx_complete, (uint32_t *)&g_taudio);
+
+    audio_set_param(&g_taudio, smpl_rate_idx, WL_16BIT);    // ASR_8KHZ, ASR_16KHZ //ASR_48KHZ
+    // audio_mic_analog_gain(&g_taudio, 1, AUDIO_MIC_40DB); // default 0DB
+
+
+    /* Use (DMA page count -1) because occur RX interrupt in first */
+    for (int i = 0; i < (AUDIO_DMA_PAGE_NUM - 1); i++) {
+        uint8_t *ptx_buf = audio_get_tx_page_adr(&g_taudio);
+        if (ptx_buf) {
+            memset(ptx_buf, 0x0, AUDIO_DMA_PAGE_SIZE);
+            audio_set_tx_page(&g_taudio, ptx_buf);
+        }
+        audio_set_rx_page(&g_taudio);
+    }
+
+
+    audio_trx_start(&g_taudio);
+}
+
+void audio_tx_complete(uint32_t arg, uint8_t *pbuf)
+{
+    uint8_t *ptx_buf;
+
+    ptx_buf = (uint8_t *)audio_get_tx_page_adr(&g_taudio);
+    if (xQueueReceiveFromISR(audio_tx_pcm_queue, ptx_buf, NULL) != pdPASS) {
+        memset(ptx_buf, 0, AUDIO_DMA_PAGE_SIZE);
+    }
+    audio_set_tx_page(&g_taudio, (uint8_t *)ptx_buf);
+}
+
+void audio_rx_complete(uint32_t arg, uint8_t *pbuf)
+{
+    audio_t *obj = (audio_t *)arg;
+    audio_set_rx_page(obj);
+}
+
+void audio_play_pcm(int16_t *buf, uint32_t len)
+{
+    for (int i = 0; i < len; i++) {
+        audio_tx_pcm_cache[audio_tx_pcm_cache_len++] = buf[i];
+        if (audio_tx_pcm_cache_len == AUDIO_DMA_PAGE_SIZE / 2) {
+            xQueueSend(audio_tx_pcm_queue, audio_tx_pcm_cache, portMAX_DELAY);
+            audio_tx_pcm_cache_len = 0;
+        }
+    }
+}
diff --git a/Arduino_package/hardware/libraries/Multimedia/src/helix_mp3_drv.h b/Arduino_package/hardware/libraries/Multimedia/src/helix_mp3_drv.h
@@ -0,0 +1,13 @@
+#ifndef HELIX_MP3_DRV_H
+#define HELIX_MP3_DRV_H
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+void audio_play_binary_array(uint8_t *srcbuf, uint32_t len);
+
+void initialize_audio(int sample_rate);
+void audio_play_pcm(int16_t *buf, uint32_t len);
+void audio_rx_complete(uint32_t arg, uint8_t *pbuf);
+void audio_tx_complete(uint32_t arg, uint8_t *pbuf);
+
+#endif
diff --git a/Arduino_package/hardware/libraries/NeuralNetwork/examples/UVCDObjectDetectionLoop/UVCDObjectDetectionLoop.ino b/Arduino_package/hardware/libraries/NeuralNetwork/examples/UVCDObjectDetectionLoop/UVCDObjectDetectionLoop.ino
@@ -4,7 +4,7 @@
  Connect to PC and use the device as a USB camera.
  Perform objects prediction when the device is connect to PC and PotPlayer.
 
- Example guide: TBD
+ Example guide: https://ameba-doc-arduino-sdk.readthedocs-hosted.com/en/latest/amebapro2/Example_Guides/Neural%20Network/UVCD%20Object%20Detection.html
 
 
  NN Model Selection
diff --git a/Arduino_package/hardware/platform.txt b/Arduino_package/hardware/platform.txt
