MP3Decoder: better handle INDATA_UNDERFLOW & MAINDATA_UNDERFLOW

This allows playback of some 128k http streams from somafm, though
glitches occur with some regularity.

```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 * 16
mp3_buffer = bytearray(16384)

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

@@ -23,6 +23,8 @@
 
 #define MAX_BUFFER_LEN (MAX_NSAMP * MAX_NGRAN * MAX_NCHAN * sizeof(int16_t))
 
+#define DO_DEBUG (0)
+
 #if defined(MICROPY_UNIX_COVERAGE)
 #define background_callback_prevent() ((void)0)
 #define background_callback_allow() ((void)0)
@@ -38,6 +40,9 @@ STATIC bool stream_readable(void *stream) {
     }
 
     mp_int_t ret = stream_p->ioctl(stream, MP_STREAM_POLL, MP_STREAM_POLL_RD | MP_STREAM_POLL_ERR | MP_STREAM_POLL_HUP, &errcode);
+    if (DO_DEBUG) {
+        mp_printf(&mp_plat_print, "stream_readable ioctl() -> %d [errcode=%d]\n", ret, errcode);
+    }
     return ret != 0;
 }
 
@@ -51,7 +56,13 @@ STATIC ssize_t stream_read(void *stream, void *buf, size_t len) {
         return -EINVAL;
     }
     mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &errcode);
+    if (DO_DEBUG) {
+        mp_printf(&mp_plat_print, "stream_read(%d) -> %d\n", (int)len, (int)out_sz);
+    }
     if (out_sz == MP_STREAM_ERROR) {
+        if (DO_DEBUG) {
+            mp_printf(&mp_plat_print, "errcode=%d\n", errcode);
+        }
         return -errcode; // CIRCUITPY-CHANGE: returns negative errcode value
     } else {
         return out_sz;
@@ -127,6 +138,10 @@ static bool mp3file_update_inbuf_always(audiomp3_mp3file_obj_t *self) {
         self->inbuf.write_off += n_read;
     }
 
+    if (DO_DEBUG) {
+        mp_printf(&mp_plat_print, "new avail=%d eof=%d\n", (int)INPUT_BUFFER_AVAILABLE(self->inbuf), self->eof);
+    }
+
     // Return true iff there are at least some useful bytes in the buffer
     return INPUT_BUFFER_AVAILABLE(self->inbuf) > 0;
 }
@@ -395,18 +410,25 @@ audioio_get_buffer_result_t audiomp3_mp3file_get_buffer(audiomp3_mp3file_obj_t *
     uint32_t *buffer_length) {
     if (!self->inbuf.buf) {
         *buffer_length = 0;
+        if (DO_DEBUG) {
+            mp_printf(&mp_plat_print, "%s:%d\n", __FILE__, __LINE__);
+        }
         return GET_BUFFER_ERROR;
     }
     if (!single_channel_output) {
         channel = 0;
     }
 
-    *buffer_length = self->frame_buffer_size;
+    size_t frame_buffer_size_bytes = self->frame_buffer_size;
+    *buffer_length = frame_buffer_size_bytes;
 
     if (channel == self->other_channel) {
         *bufptr = (uint8_t *)(self->pcm_buffer[self->other_buffer_index] + channel);
         self->other_channel = -1;
         self->samples_decoded += *buffer_length / sizeof(int16_t);
+        if (DO_DEBUG) {
+            mp_printf(&mp_plat_print, "%s:%d\n", __FILE__, __LINE__);
+        }
         return GET_BUFFER_MORE_DATA;
     }
 
@@ -428,15 +450,26 @@ audioio_get_buffer_result_t audiomp3_mp3file_get_buffer(audiomp3_mp3file_obj_t *
     CONSUME(self, BYTES_LEFT(self) - bytes_left);
 
     if (err) {
-        *buffer_length = 0;
-        return GET_BUFFER_DONE;
+        memset(buffer, 0, frame_buffer_size_bytes);
+        if (DO_DEBUG) {
+            mp_printf(&mp_plat_print, "%s:%d err=%d\n", __FILE__, __LINE__, err);
+        }
+        if (err != ERR_MP3_INDATA_UNDERFLOW && err != ERR_MP3_MAINDATA_UNDERFLOW) {
+            memset(buffer, 0, self->frame_buffer_size);
+            *buffer_length = 0;
+            self->eof = true;
+            return GET_BUFFER_ERROR;
+        }
     }
 
-    self->samples_decoded += *buffer_length / sizeof(int16_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;
 
+    if (DO_DEBUG) {
+        mp_printf(&mp_plat_print, "%s:%d result=%d\n", __FILE__, __LINE__, result);
+    }
     if (INPUT_BUFFER_SPACE(self->inbuf) > 512) {
         background_callback_add(
             &self->inbuf_fill_cb,