mp3.c 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365
  1. #include <rtthread.h>
  2. #include <dfs_posix.h>
  3. #include <mp3/pub/mp3dec.h>
  4. #include "board.h"
  5. #include "netbuffer.h"
  6. #define MP3_AUDIO_BUF_SZ 4096
  7. rt_uint8_t mp3_fd_buffer[MP3_AUDIO_BUF_SZ];
  8. struct mp3_decoder
  9. {
  10. /* mp3 information */
  11. HMP3Decoder decoder;
  12. MP3FrameInfo frame_info;
  13. rt_uint32_t frames;
  14. /* mp3 file descriptor */
  15. rt_size_t (*fetch_data)(void* parameter, rt_uint8_t *buffer, rt_size_t length);
  16. void* fetch_parameter;
  17. /* mp3 read session */
  18. rt_uint8_t *read_buffer;
  19. rt_uint8_t* read_ptr;
  20. rt_int32_t read_offset;
  21. rt_uint32_t bytes_left, bytes_left_before_decoding;
  22. /* audio device */
  23. rt_device_t snd_device;
  24. };
  25. static rt_err_t mp3_decoder_tx_done(rt_device_t dev, void *buffer)
  26. {
  27. /* release memory block */
  28. sbuf_release(buffer);
  29. return RT_EOK;
  30. }
  31. void mp3_decoder_init(struct mp3_decoder* decoder)
  32. {
  33. RT_ASSERT(decoder != RT_NULL);
  34. /* init read session */
  35. decoder->read_ptr = RT_NULL;
  36. decoder->bytes_left_before_decoding = decoder->bytes_left = 0;
  37. decoder->frames = 0;
  38. // decoder->read_buffer = rt_malloc(MP3_AUDIO_BUF_SZ);
  39. decoder->read_buffer = &mp3_fd_buffer[0];
  40. if (decoder->read_buffer == RT_NULL) return;
  41. decoder->decoder = MP3InitDecoder();
  42. /* open audio device */
  43. decoder->snd_device = rt_device_find("snd");
  44. if (decoder->snd_device != RT_NULL)
  45. {
  46. /* set tx complete call back function */
  47. rt_device_set_tx_complete(decoder->snd_device, mp3_decoder_tx_done);
  48. rt_device_open(decoder->snd_device, RT_DEVICE_OFLAG_WRONLY);
  49. }
  50. }
  51. void mp3_decoder_detach(struct mp3_decoder* decoder)
  52. {
  53. RT_ASSERT(decoder != RT_NULL);
  54. /* close audio device */
  55. if (decoder->snd_device != RT_NULL)
  56. rt_device_close(decoder->snd_device);
  57. /* release mp3 decoder */
  58. MP3FreeDecoder(decoder->decoder);
  59. }
  60. struct mp3_decoder* mp3_decoder_create()
  61. {
  62. struct mp3_decoder* decoder;
  63. /* allocate object */
  64. decoder = (struct mp3_decoder*) rt_malloc (sizeof(struct mp3_decoder));
  65. if (decoder != RT_NULL)
  66. {
  67. mp3_decoder_init(decoder);
  68. }
  69. return decoder;
  70. }
  71. void mp3_decoder_delete(struct mp3_decoder* decoder)
  72. {
  73. RT_ASSERT(decoder != RT_NULL);
  74. /* de-init mp3 decoder object */
  75. mp3_decoder_detach(decoder);
  76. /* release this object */
  77. rt_free(decoder);
  78. }
  79. rt_uint16_t is_first = 1;
  80. rt_uint32_t current_offset = 0;
  81. static rt_int32_t mp3_decoder_fill_buffer(struct mp3_decoder* decoder)
  82. {
  83. rt_size_t bytes_read;
  84. rt_size_t bytes_to_read;
  85. // rt_kprintf("left: %d. refilling inbuffer...\n", decoder->bytes_left);
  86. if (decoder->bytes_left > 0)
  87. {
  88. // better: move unused rest of buffer to the start
  89. rt_memmove(decoder->read_buffer, decoder->read_ptr, decoder->bytes_left);
  90. }
  91. bytes_to_read = (MP3_AUDIO_BUF_SZ - decoder->bytes_left) & ~(512 - 1);
  92. // rt_kprintf("read bytes: %d\n", bytes_to_read);
  93. if (is_first) is_first = 0;
  94. else current_offset += MP3_AUDIO_BUF_SZ - decoder->bytes_left;
  95. bytes_read = decoder->fetch_data(decoder->fetch_parameter,
  96. (rt_uint8_t *)(decoder->read_buffer + decoder->bytes_left),
  97. bytes_to_read);
  98. if (bytes_read == bytes_to_read)
  99. {
  100. decoder->read_ptr = decoder->read_buffer;
  101. decoder->read_offset = 0;
  102. decoder->bytes_left = decoder->bytes_left + bytes_to_read;
  103. return 0;
  104. }
  105. else
  106. {
  107. rt_kprintf("can't read more data");
  108. return -1;
  109. }
  110. }
  111. int mp3_decoder_run(struct mp3_decoder* decoder)
  112. {
  113. int err;
  114. rt_uint16_t* buffer;
  115. RT_ASSERT(decoder != RT_NULL);
  116. if ((decoder->read_ptr == RT_NULL) || decoder->bytes_left < 2*MAINBUF_SIZE)
  117. {
  118. if(mp3_decoder_fill_buffer(decoder) != 0)
  119. return -1;
  120. }
  121. // rt_kprintf("read offset: 0x%08x\n", decoder->read_ptr - decoder->read_buffer);
  122. decoder->read_offset = MP3FindSyncWord(decoder->read_ptr, decoder->bytes_left);
  123. if (decoder->read_offset < 0)
  124. {
  125. rt_kprintf("Error: MP3FindSyncWord returned <0");
  126. if(mp3_decoder_fill_buffer(decoder) != 0)
  127. return -1;
  128. }
  129. // rt_kprintf("sync position: %x\n", decoder->read_offset);
  130. decoder->read_ptr += decoder->read_offset;
  131. decoder->bytes_left -= decoder->read_offset;
  132. decoder->bytes_left_before_decoding = decoder->bytes_left;
  133. #if 0
  134. // check if this is really a valid frame
  135. // (the decoder does not seem to calculate CRC, so make some plausibility checks)
  136. if (!(MP3GetNextFrameInfo(decoder->decoder, &decoder->frame_info, decoder->read_ptr) == 0 &&
  137. decoder->frame_info.nChans == 2 &&
  138. decoder->frame_info.version == 0))
  139. {
  140. rt_kprintf("this is an invalid frame\n");
  141. // advance data pointer
  142. // TODO: handle bytes_left == 0
  143. RT_ASSERT(decoder->bytes_left > 0);
  144. decoder->bytes_left --;
  145. decoder->read_ptr ++;
  146. return 0;
  147. }
  148. if (decoder->bytes_left < 1024)
  149. {
  150. if(mp3_decoder_fill_buffer(decoder) != 0)
  151. return -1;
  152. }
  153. #endif
  154. /* get a decoder buffer */
  155. buffer = (rt_uint16_t*)sbuf_alloc();
  156. // rt_kprintf("bytes left before decode: %d\n", decoder->bytes_left);
  157. err = MP3Decode(decoder->decoder, &decoder->read_ptr,
  158. (int*)&decoder->bytes_left, (short*)buffer, 0);
  159. // rt_kprintf("bytes left after decode: %d\n", decoder->bytes_left);
  160. decoder->frames++;
  161. if (err != ERR_MP3_NONE)
  162. {
  163. switch (err)
  164. {
  165. case ERR_MP3_INDATA_UNDERFLOW:
  166. rt_kprintf("ERR_MP3_INDATA_UNDERFLOW\n");
  167. decoder->bytes_left = 0;
  168. if(mp3_decoder_fill_buffer(decoder) != 0)
  169. return -1;
  170. break;
  171. case ERR_MP3_MAINDATA_UNDERFLOW:
  172. /* do nothing - next call to decode will provide more mainData */
  173. rt_kprintf("ERR_MP3_MAINDATA_UNDERFLOW\n");
  174. break;
  175. case ERR_MP3_INVALID_FRAMEHEADER:
  176. rt_kprintf("ERR_MP3_INVALID_FRAMEHEADER\n");
  177. rt_kprintf("current offset: 0x%08x, frames: %d\n", current_offset, decoder->frames);
  178. /* dump sector */
  179. {
  180. rt_uint8_t *ptr;
  181. rt_size_t size = 0, col = 0;
  182. ptr = decoder->read_buffer;
  183. rt_kprintf(" 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
  184. rt_kprintf("00 ");
  185. while (size ++ < 512)
  186. {
  187. rt_kprintf("%02x ", *ptr ++);
  188. if (size % 16 == 0) rt_kprintf("\n%02x ", ++col);
  189. }
  190. }
  191. RT_ASSERT(0);
  192. // break;
  193. case ERR_MP3_INVALID_HUFFCODES:
  194. rt_kprintf("ERR_MP3_INVALID_HUFFCODES\n");
  195. break;
  196. default:
  197. rt_kprintf("unknown error: %i\n", err);
  198. // skip this frame
  199. if (decoder->bytes_left > 0)
  200. {
  201. decoder->bytes_left --;
  202. decoder->read_ptr ++;
  203. }
  204. else
  205. {
  206. // TODO
  207. RT_ASSERT(0);
  208. }
  209. break;
  210. }
  211. /* release this memory block */
  212. sbuf_release(buffer);
  213. }
  214. else
  215. {
  216. /* no error */
  217. MP3GetLastFrameInfo(decoder->decoder, &decoder->frame_info);
  218. #ifdef MP3_DECODER_TRACE
  219. rt_kprintf("Bitrate: %i\n", decoder->frame_info.bitrate);
  220. rt_kprintf("%i samples\n", decoder->frame_info.outputSamps);
  221. rt_kprintf("%lu Hz, %i kbps\n", decoder->frame_info.samprate,
  222. decoder->frame_info.bitrate/1000);
  223. #endif
  224. /* set sample rate */
  225. /* write to sound device */
  226. rt_device_write(decoder->snd_device, 0, buffer, decoder->frame_info.outputSamps * 2);
  227. // rt_mp_free(buffer);
  228. }
  229. return 0;
  230. }
  231. #include <finsh.h>
  232. rt_size_t fd_fetch(void* parameter, rt_uint8_t *buffer, rt_size_t length)
  233. {
  234. int fd = (int)parameter;
  235. return read(fd, (char*)buffer, length);
  236. }
  237. void mp3(char* filename)
  238. {
  239. int fd;
  240. struct mp3_decoder* decoder;
  241. fd = open(filename, O_RDONLY, 0);
  242. if (fd >= 0)
  243. {
  244. decoder = mp3_decoder_create();
  245. if (decoder != RT_NULL)
  246. {
  247. decoder->fetch_data = fd_fetch;
  248. decoder->fetch_parameter = (void*)fd;
  249. while (mp3_decoder_run(decoder) != -1);
  250. close(fd);
  251. /* delete decoder object */
  252. mp3_decoder_delete(decoder);
  253. }
  254. }
  255. }
  256. FINSH_FUNCTION_EXPORT(mp3, mp3 decode test);
  257. #if STM32_EXT_SRAM
  258. /* http mp3 */
  259. #include "http.h"
  260. static rt_size_t http_fetch(rt_uint8_t* ptr, rt_size_t len, void* parameter)
  261. {
  262. struct http_session* session = (struct http_session*)parameter;
  263. RT_ASSERT(session != RT_NULL);
  264. return http_session_read(session, ptr, len);
  265. }
  266. static void http_close(void* parameter)
  267. {
  268. struct http_session* session = (struct http_session*)parameter;
  269. RT_ASSERT(session != RT_NULL);
  270. http_session_close(session);
  271. }
  272. rt_size_t http_data_fetch(void* parameter, rt_uint8_t *buffer, rt_size_t length)
  273. {
  274. return net_buf_read(buffer, length);
  275. }
  276. void http_mp3(char* url)
  277. {
  278. struct http_session* session;
  279. struct mp3_decoder* decoder;
  280. session = http_session_open(url);
  281. if (session != RT_NULL)
  282. {
  283. /* add a job to netbuf worker */
  284. net_buf_add_job(http_fetch, http_close, (void*)session);
  285. decoder = mp3_decoder_create();
  286. if (decoder != RT_NULL)
  287. {
  288. decoder->fetch_data = http_data_fetch;
  289. decoder->fetch_parameter = RT_NULL;
  290. while (mp3_decoder_run(decoder) != -1);
  291. /* delete decoder object */
  292. mp3_decoder_delete(decoder);
  293. }
  294. session = RT_NULL;
  295. }
  296. }
  297. FINSH_FUNCTION_EXPORT(http_mp3, http mp3 decode test);
  298. #endif