MP3Decoder: avoid all blocking reads in background

This gets MP3 playback of a soma.fm stream working for up to a minute
at a time, though it's still vulnerable to network glitches.

 * the buffer can empty, in which case a single block of audio
   plays repeatedly in max headroom stutter fashion
 * the server eventually (after 1 to 5 5 minutes) stops getting packets
   at all. At this point stream playback stops, with the internal error
   indicating a problem MP3 decoding (which doesn't quite make sense):
   -9, ERR_MP3_INVALID_HUFFCODES.
 * other combinations of audiomixer buffer & mp3 buffer might give
   different results
```py
import time

import adafruit_connection_manager
import adafruit_requests
import audiobusio
import audiomixer
import audiomp3
import board
import wifi

pool = adafruit_connection_manager.get_radio_socketpool(wifi.radio)
ssl_context = adafruit_connection_manager.get_radio_ssl_context(wifi.radio)
requests = adafruit_requests.Session(pool, ssl_context)

# todo: parse PLS files like https://somafm.com/nossl/dronezone.pls
# todo: figure out why https URLs don't work at all (missing select?)
# STREAMING_URL = "http://ice2.somafm.com/dronezone-128-mp3"
STREAMING_URL = "http://ice4.somafm.com/tikitime-128-mp3"


def get_mp3_stream():
    if STREAMING_URL.startswith("http:") or STREAMING_URL.startswith("https:"):
        return requests.get(STREAMING_URL, headers={"connection": "close"}).socket
    return open(STREAMING_URL, "rb")


mixer_buffer_size = 1152 * 2
mp3_buffer = bytearray(32768)

with audiobusio.I2SOut(
    bit_clock=board.D12, word_select=board.D13, data=board.D11
) as i2s, get_mp3_stream() as stream, audiomp3.MP3Decoder(
    stream, mp3_buffer
) as sample, audiomixer.Mixer(
    channel_count=2, sample_rate=44100, buffer_size=mixer_buffer_size
) as m:

    v = m.voice[0]
    print(sample)

    i2s.play(m)

    v.play(sample, loop=False)
    while v.playing:
        time.sleep(0.1)
```

Author: jepler

shared-module/audiomp3/MP3Decoder.c

@@ -104,7 +104,7 @@ static off_t stream_lseek(void *stream, off_t offset, int whence) {
  *
  * Sets self->eof if any read of the file returns 0 bytes
  */
-static bool mp3file_update_inbuf_always(audiomp3_mp3file_obj_t *self) {
+static bool mp3file_update_inbuf_always(audiomp3_mp3file_obj_t *self, bool block_ok) {
     if (self->eof || INPUT_BUFFER_SPACE(self->inbuf) == 0) {
         return INPUT_BUFFER_AVAILABLE(self->inbuf) > 0;
     }
@@ -118,7 +118,7 @@ static bool mp3file_update_inbuf_always(audiomp3_mp3file_obj_t *self) {
         self->inbuf.read_off = 0;
     }
 
-    for (size_t to_read; !self->eof && (to_read = INPUT_BUFFER_SPACE(self->inbuf)) > 0;) {
+    for (size_t to_read; !self->eof && (to_read = INPUT_BUFFER_SPACE(self->inbuf)) > 0 && (block_ok || stream_readable(self->stream));) {
         uint8_t *write_ptr = self->inbuf.buf + self->inbuf.write_off;
         ssize_t n_read = stream_read(self->stream, write_ptr, to_read);
 
@@ -152,8 +152,11 @@ static bool mp3file_update_inbuf_always(audiomp3_mp3file_obj_t *self) {
  */
 static void mp3file_update_inbuf_cb(void *self_in) {
     audiomp3_mp3file_obj_t *self = self_in;
+    if (common_hal_audiomp3_mp3file_deinited(self_in)) {
+        return;
+    }
     if (!self->eof && stream_readable(self->stream)) {
-        mp3file_update_inbuf_always(self);
+        mp3file_update_inbuf_always(self, false);
     }
 
     #if !defined(MICROPY_UNIX_COVERAGE)
@@ -170,22 +173,22 @@ static void mp3file_update_inbuf_cb(void *self_in) {
  *
  * Returns the same as mp3file_update_inbuf_always.
  */
-static bool mp3file_update_inbuf_half(audiomp3_mp3file_obj_t *self) {
+static bool mp3file_update_inbuf_half(audiomp3_mp3file_obj_t *self, bool block_ok) {
     // If buffer is over half full, do nothing
     if (INPUT_BUFFER_SPACE(self->inbuf) < self->inbuf.size / 2) {
         return true;
     }
 
-    return mp3file_update_inbuf_always(self);
+    return mp3file_update_inbuf_always(self, block_ok);
 }
 
 #define READ_PTR(self) (INPUT_BUFFER_READ_PTR(self->inbuf))
 #define BYTES_LEFT(self) (INPUT_BUFFER_AVAILABLE(self->inbuf))
 #define CONSUME(self, n) (INPUT_BUFFER_CONSUME(self->inbuf, n))
 
 // http://id3.org/id3v2.3.0
-static void mp3file_skip_id3v2(audiomp3_mp3file_obj_t *self) {
-    mp3file_update_inbuf_half(self);
+static void mp3file_skip_id3v2(audiomp3_mp3file_obj_t *self, bool block_ok) {
+    mp3file_update_inbuf_half(self, block_ok);
     if (BYTES_LEFT(self) < 10) {
         return;
     }
@@ -206,6 +209,9 @@ static void mp3file_skip_id3v2(audiomp3_mp3file_obj_t *self) {
     int32_t size = (data[6] << 21) | (data[7] << 14) | (data[8] << 7) | (data[9]);
     size += 10; // size excludes the "header" (but not the "extended header")
     // First, deduct from size whatever is left in buffer
+    if (DO_DEBUG) {
+        mp_printf(&mp_plat_print, "%s:%d id3 size %d\n", __FILE__, __LINE__, size);
+    }
     uint32_t to_consume = MIN(size, BYTES_LEFT(self));
     CONSUME(self, to_consume);
     size -= to_consume;
@@ -217,7 +223,7 @@ static void mp3file_skip_id3v2(audiomp3_mp3file_obj_t *self) {
 
     // Couldn't seek (might be a socket), so need to actually read and discard all that data
     while (size > 0 && !self->eof) {
-        mp3file_update_inbuf_always(self);
+        mp3file_update_inbuf_always(self, true);
         to_consume = MIN(size, BYTES_LEFT(self));
         CONSUME(self, to_consume);
         size -= to_consume;
@@ -227,29 +233,29 @@ static void mp3file_skip_id3v2(audiomp3_mp3file_obj_t *self) {
 /* If a sync word can be found, advance to it and return true.  Otherwise,
  * return false.
  */
-static bool mp3file_find_sync_word(audiomp3_mp3file_obj_t *self) {
+static bool mp3file_find_sync_word(audiomp3_mp3file_obj_t *self, bool block_ok) {
     do {
-        mp3file_update_inbuf_half(self);
+        mp3file_update_inbuf_half(self, block_ok);
         int offset = MP3FindSyncWord(READ_PTR(self), BYTES_LEFT(self));
         if (offset >= 0) {
             CONSUME(self, offset);
-            mp3file_update_inbuf_half(self);
+            mp3file_update_inbuf_half(self, block_ok);
             return true;
         }
         CONSUME(self, MAX(0, BYTES_LEFT(self) - 16));
     } while (!self->eof);
     return false;
 }
 
-static bool mp3file_get_next_frame_info(audiomp3_mp3file_obj_t *self, MP3FrameInfo *fi) {
+static bool mp3file_get_next_frame_info(audiomp3_mp3file_obj_t *self, MP3FrameInfo *fi, bool block_ok) {
     int err;
     do {
         err = MP3GetNextFrameInfo(self->decoder, fi, READ_PTR(self));
         if (err == ERR_MP3_NONE) {
             break;
         }
         CONSUME(self, 1);
-        mp3file_find_sync_word(self);
+        mp3file_find_sync_word(self, block_ok);
     } while (!self->eof);
     return err == ERR_MP3_NONE;
 }
@@ -328,8 +334,8 @@ void common_hal_audiomp3_mp3file_set_file(audiomp3_mp3file_obj_t *self, mp_obj_t
     INPUT_BUFFER_CLEAR(self->inbuf);
     self->eof = 0;
     self->other_channel = -1;
-    mp3file_update_inbuf_half(self);
-    mp3file_find_sync_word(self);
+    mp3file_update_inbuf_half(self, true);
+    mp3file_find_sync_word(self, true);
     // It **SHOULD** not be necessary to do this; the buffer should be filled
     // with fresh content before it is returned by get_buffer().  The fact that
     // this is necessary to avoid a glitch at the start of playback of a second
@@ -338,7 +344,7 @@ void common_hal_audiomp3_mp3file_set_file(audiomp3_mp3file_obj_t *self, mp_obj_t
     memset(self->pcm_buffer[0], 0, MAX_BUFFER_LEN);
     memset(self->pcm_buffer[1], 0, MAX_BUFFER_LEN);
     MP3FrameInfo fi;
-    bool result = mp3file_get_next_frame_info(self, &fi);
+    bool result = mp3file_get_next_frame_info(self, &fi, true);
     background_callback_allow();
     if (!result) {
         mp_raise_msg(&mp_type_RuntimeError,
@@ -353,7 +359,9 @@ void common_hal_audiomp3_mp3file_set_file(audiomp3_mp3file_obj_t *self, mp_obj_t
 }
 
 void common_hal_audiomp3_mp3file_deinit(audiomp3_mp3file_obj_t *self) {
-    MP3FreeDecoder(self->decoder);
+    if (self->decoder) {
+        MP3FreeDecoder(self->decoder);
+    }
     self->decoder = NULL;
     self->inbuf.buf = NULL;
     self->pcm_buffer[0] = NULL;
@@ -397,8 +405,8 @@ void audiomp3_mp3file_reset_buffer(audiomp3_mp3file_obj_t *self,
         self->eof = 0;
         self->samples_decoded = 0;
         self->other_channel = -1;
-        mp3file_skip_id3v2(self);
-        mp3file_find_sync_word(self);
+        mp3file_skip_id3v2(self, false);
+        mp3file_find_sync_word(self, false);
     }
     background_callback_allow();
 }
@@ -439,8 +447,8 @@ audioio_get_buffer_result_t audiomp3_mp3file_get_buffer(audiomp3_mp3file_obj_t *
     int16_t *buffer = (int16_t *)(void *)self->pcm_buffer[self->buffer_index];
     *bufptr = (uint8_t *)buffer;
 
-    mp3file_skip_id3v2(self);
-    if (!mp3file_find_sync_word(self)) {
+    mp3file_skip_id3v2(self, false);
+    if (!mp3file_find_sync_word(self, false)) {
         *buffer_length = 0;
         return self->eof ? GET_BUFFER_DONE : GET_BUFFER_ERROR;
     }
@@ -464,8 +472,8 @@ audioio_get_buffer_result_t audiomp3_mp3file_get_buffer(audiomp3_mp3file_obj_t *
 
     self->samples_decoded += frame_buffer_size_bytes / sizeof(int16_t);
 
-    mp3file_skip_id3v2(self);
-    int result = mp3file_find_sync_word(self) ? GET_BUFFER_MORE_DATA : GET_BUFFER_DONE;
+    mp3file_skip_id3v2(self, false);
+    int result = mp3file_find_sync_word(self, false) ? GET_BUFFER_MORE_DATA : GET_BUFFER_DONE;
 
     if (DO_DEBUG) {
         mp_printf(&mp_plat_print, "%s:%d result=%d\n", __FILE__, __LINE__, result);
@@ -477,6 +485,9 @@ audioio_get_buffer_result_t audiomp3_mp3file_get_buffer(audiomp3_mp3file_obj_t *
             self);
     }
 
+    if (DO_DEBUG) {
+        mp_printf(&mp_plat_print, "post-decode avail=%d eof=%d\n", (int)INPUT_BUFFER_AVAILABLE(self->inbuf), self->eof);
+    }
     return result;
 }