Merge pull request #2010 from jepler/audiocore

audiocore: Factor from audioio

8 files changed, 1085 insertions, 0 deletions

diff --git a/shared-module/audiocore/Mixer.c b/shared-module/audiocore/Mixer.c
new file mode 100644
index 000000000..da66bb36e
--- /dev/null
+++ b/shared-module/audiocore/Mixer.c
@@ -0,0 +1,341 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/audiocore/Mixer.h"
+
+#include <stdint.h>
+
+#include "py/runtime.h"
+#include "shared-module/audiocore/__init__.h"
+#include "shared-module/audiocore/RawSample.h"
+
+void common_hal_audioio_mixer_construct(audioio_mixer_obj_t* self,
+                                        uint8_t voice_count,
+                                        uint32_t buffer_size,
+                                        uint8_t bits_per_sample,
+                                        bool samples_signed,
+                                        uint8_t channel_count,
+                                        uint32_t sample_rate) {
+    self->len = buffer_size / 2 / sizeof(uint32_t) * sizeof(uint32_t);
+
+    self->first_buffer = m_malloc(self->len, false);
+    if (self->first_buffer == NULL) {
+        common_hal_audioio_mixer_deinit(self);
+        mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate first buffer"));
+    }
+
+    self->second_buffer = m_malloc(self->len, false);
+    if (self->second_buffer == NULL) {
+        common_hal_audioio_mixer_deinit(self);
+        mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate second buffer"));
+    }
+
+    self->bits_per_sample = bits_per_sample;
+    self->samples_signed = samples_signed;
+    self->channel_count = channel_count;
+    self->sample_rate = sample_rate;
+    self->voice_count = voice_count;
+
+    for (uint8_t i = 0; i < self->voice_count; i++) {
+        self->voice[i].sample = NULL;
+    }
+}
+
+void common_hal_audioio_mixer_deinit(audioio_mixer_obj_t* self) {
+    self->first_buffer = NULL;
+    self->second_buffer = NULL;
+}
+
+bool common_hal_audioio_mixer_deinited(audioio_mixer_obj_t* self) {
+    return self->first_buffer == NULL;
+}
+
+uint32_t common_hal_audioio_mixer_get_sample_rate(audioio_mixer_obj_t* self) {
+    return self->sample_rate;
+}
+
+void common_hal_audioio_mixer_play(audioio_mixer_obj_t* self, mp_obj_t sample, uint8_t v, bool loop) {
+    if (v >= self->voice_count) {
+        mp_raise_ValueError(translate("Voice index too high"));
+    }
+    if (audiosample_sample_rate(sample) != self->sample_rate) {
+        mp_raise_ValueError(translate("The sample's sample rate does not match the mixer's"));
+    }
+    if (audiosample_channel_count(sample) != self->channel_count) {
+        mp_raise_ValueError(translate("The sample's channel count does not match the mixer's"));
+    }
+    if (audiosample_bits_per_sample(sample) != self->bits_per_sample) {
+        mp_raise_ValueError(translate("The sample's bits_per_sample does not match the mixer's"));
+    }
+    bool single_buffer;
+    bool samples_signed;
+    uint32_t max_buffer_length;
+    uint8_t spacing;
+    audiosample_get_buffer_structure(sample, false, &single_buffer, &samples_signed,
+                                     &max_buffer_length, &spacing);
+    if (samples_signed != self->samples_signed) {
+        mp_raise_ValueError(translate("The sample's signedness does not match the mixer's"));
+    }
+    audioio_mixer_voice_t* voice = &self->voice[v];
+    voice->sample = sample;
+    voice->loop = loop;
+
+    audiosample_reset_buffer(sample, false, 0);
+    audioio_get_buffer_result_t result = audiosample_get_buffer(sample, false, 0, (uint8_t**) &voice->remaining_buffer, &voice->buffer_length);
+    // Track length in terms of words.
+    voice->buffer_length /= sizeof(uint32_t);
+    voice->more_data = result == GET_BUFFER_MORE_DATA;
+}
+
+void common_hal_audioio_mixer_stop_voice(audioio_mixer_obj_t* self, uint8_t voice) {
+    self->voice[voice].sample = NULL;
+}
+
+bool common_hal_audioio_mixer_get_playing(audioio_mixer_obj_t* self) {
+    for (int32_t v = 0; v < self->voice_count; v++) {
+        if (self->voice[v].sample != NULL) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void audioio_mixer_reset_buffer(audioio_mixer_obj_t* self,
+                                bool single_channel,
+                                uint8_t channel) {
+    for (int32_t i = 0; i < self->voice_count; i++) {
+        self->voice[i].sample = NULL;
+    }
+}
+
+uint32_t add8signed(uint32_t a, uint32_t b) {
+    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
+    return __QADD8(a, b);
+    #else
+    uint32_t result = 0;
+    for (int8_t i = 0; i < 4; i++) {
+        int8_t ai = a >> (sizeof(int8_t) * 8 * i);
+        int8_t bi = b >> (sizeof(int8_t) * 8 * i);
+        int32_t intermediate = (int32_t) ai + bi;
+        if (intermediate > CHAR_MAX) {
+            intermediate = CHAR_MAX;
+        } else if (intermediate < CHAR_MIN) {
+            //intermediate = CHAR_MIN;
+        }
+        result |= (((uint32_t) intermediate) & 0xff) << (sizeof(int8_t) * 8 * i);
+    }
+    return result;
+    #endif
+}
+
+uint32_t add8unsigned(uint32_t a, uint32_t b) {
+    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
+    // Subtract out the DC offset, add and then shift back.
+    a = __USUB8(a, 0x80808080);
+    b = __USUB8(b, 0x80808080);
+    uint32_t sum = __QADD8(a, b);
+    return __UADD8(sum, 0x80808080);
+    #else
+    uint32_t result = 0;
+    for (int8_t i = 0; i < 4; i++) {
+        int8_t ai = (a >> (sizeof(uint8_t) * 8 * i)) - 128;
+        int8_t bi = (b >> (sizeof(uint8_t) * 8 * i)) - 128;
+        int32_t intermediate = (int32_t) ai + bi;
+        if (intermediate > UCHAR_MAX) {
+            intermediate = UCHAR_MAX;
+        }
+        result |= ((uint8_t) intermediate + 128) << (sizeof(uint8_t) * 8 * i);
+    }
+    return result;
+    #endif
+}
+
+uint32_t add16signed(uint32_t a, uint32_t b) {
+    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
+    return __QADD16(a, b);
+    #else
+    uint32_t result = 0;
+    for (int8_t i = 0; i < 2; i++) {
+        int16_t ai = a >> (sizeof(int16_t) * 8 * i);
+        int16_t bi = b >> (sizeof(int16_t) * 8 * i);
+        int32_t intermediate = (int32_t) ai + bi;
+        if (intermediate > SHRT_MAX) {
+            intermediate = SHRT_MAX;
+        } else if (intermediate < SHRT_MIN) {
+            intermediate = SHRT_MIN;
+        }
+        result |= (((uint32_t) intermediate) & 0xffff) << (sizeof(int16_t) * 8 * i);
+    }
+    return result;
+    #endif
+}
+
+uint32_t add16unsigned(uint32_t a, uint32_t b) {
+    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
+    // Subtract out the DC offset, add and then shift back.
+    a = __USUB16(a, 0x80008000);
+    b = __USUB16(b, 0x80008000);
+    uint32_t sum = __QADD16(a, b);
+    return __UADD16(sum, 0x80008000);
+    #else
+    uint32_t result = 0;
+    for (int8_t i = 0; i < 2; i++) {
+        int16_t ai = (a >> (sizeof(uint16_t) * 8 * i)) - 0x8000;
+        int16_t bi = (b >> (sizeof(uint16_t) * 8 * i)) - 0x8000;
+        int32_t intermediate = (int32_t) ai + bi;
+        if (intermediate > USHRT_MAX) {
+            intermediate = USHRT_MAX;
+        }
+        result |= ((uint16_t) intermediate + 0x8000) << (sizeof(int16_t) * 8 * i);
+    }
+    return result;
+    #endif
+}
+
+audioio_get_buffer_result_t audioio_mixer_get_buffer(audioio_mixer_obj_t* self,
+                                                     bool single_channel,
+                                                     uint8_t channel,
+                                                     uint8_t** buffer,
+                                                     uint32_t* buffer_length) {
+    if (!single_channel) {
+        channel = 0;
+    }
+
+    uint32_t channel_read_count = self->left_read_count;
+    if (channel == 1) {
+        channel_read_count = self->right_read_count;
+    }
+    *buffer_length = self->len;
+
+    bool need_more_data = self->read_count == channel_read_count;
+    if (need_more_data) {
+        uint32_t* word_buffer;
+        if (self->use_first_buffer) {
+            *buffer = (uint8_t*) self->first_buffer;
+            word_buffer = self->first_buffer;
+        } else {
+            *buffer = (uint8_t*) self->second_buffer;
+            word_buffer = self->second_buffer;
+        }
+        self->use_first_buffer = !self->use_first_buffer;
+        bool voices_active = false;
+        for (int32_t v = 0; v < self->voice_count; v++) {
+            audioio_mixer_voice_t* voice = &self->voice[v];
+
+            uint32_t j = 0;
+            bool voice_done = voice->sample == NULL;
+            for (uint32_t i = 0; i < self->len / sizeof(uint32_t); i++) {
+                if (!voice_done && j >= voice->buffer_length) {
+                    if (!voice->more_data) {
+                        if (voice->loop) {
+                            audiosample_reset_buffer(voice->sample, false, 0);
+                        } else {
+                            voice->sample = NULL;
+                            voice_done = true;
+                        }
+                    }
+                    if (!voice_done) {
+                        // Load another buffer
+                        audioio_get_buffer_result_t result = audiosample_get_buffer(voice->sample, false, 0, (uint8_t**) &voice->remaining_buffer, &voice->buffer_length);
+                        // Track length in terms of words.
+                        voice->buffer_length /= sizeof(uint32_t);
+                        voice->more_data = result == GET_BUFFER_MORE_DATA;
+                        j = 0;
+                    }
+                }
+                // First active voice gets copied over verbatim.
+                uint32_t sample_value;
+                if (voice_done) {
+                    // Exit early if another voice already set all samples once.
+                    if (voices_active) {
+                        continue;
+                    }
+                    sample_value = 0;
+                    if (!self->samples_signed) {
+                        if (self->bits_per_sample == 8) {
+                            sample_value = 0x7f7f7f7f;
+                        } else {
+                            sample_value = 0x7fff7fff;
+                        }
+                    }
+                } else {
+                    sample_value = voice->remaining_buffer[j];
+                }
+
+                if (!voices_active) {
+                    word_buffer[i] = sample_value;
+                } else {
+                    if (self->bits_per_sample == 8) {
+                        if (self->samples_signed) {
+                            word_buffer[i] = add8signed(word_buffer[i], sample_value);
+                        } else {
+                            word_buffer[i] = add8unsigned(word_buffer[i], sample_value);
+                        }
+                    } else {
+                        if (self->samples_signed) {
+                            word_buffer[i] = add16signed(word_buffer[i], sample_value);
+                        } else {
+                            word_buffer[i] = add16unsigned(word_buffer[i], sample_value);
+                        }
+                    }
+                }
+                j++;
+            }
+            voice->buffer_length -= j;
+            voice->remaining_buffer += j;
+
+            voices_active = true;
+        }
+
+        self->read_count += 1;
+    } else if (!self->use_first_buffer) {
+        *buffer = (uint8_t*) self->first_buffer;
+    } else {
+        *buffer = (uint8_t*) self->second_buffer;
+    }
+
+
+    if (channel == 0) {
+        self->left_read_count += 1;
+    } else if (channel == 1) {
+        self->right_read_count += 1;
+        *buffer = *buffer + self->bits_per_sample / 8;
+    }
+    return GET_BUFFER_MORE_DATA;
+}
+
+void audioio_mixer_get_buffer_structure(audioio_mixer_obj_t* self, bool single_channel,
+                                        bool* single_buffer, bool* samples_signed,
+                                        uint32_t* max_buffer_length, uint8_t* spacing) {
+    *single_buffer = false;
+    *samples_signed = self->samples_signed;
+    *max_buffer_length = self->len;
+    if (single_channel) {
+        *spacing = self->channel_count;
+    } else {
+        *spacing = 1;
+    }
+}
diff --git a/shared-module/audiocore/Mixer.h b/shared-module/audiocore/Mixer.h
new file mode 100644
index 000000000..22eb6a37f
--- /dev/null
+++ b/shared-module/audiocore/Mixer.h
@@ -0,0 +1,75 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_MIXER_H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_MIXER_H
+
+#include "py/obj.h"
+
+#include "shared-module/audiocore/__init__.h"
+
+typedef struct {
+    mp_obj_t sample;
+    bool loop;
+    bool more_data;
+    uint32_t* remaining_buffer;
+    uint32_t buffer_length;
+} audioio_mixer_voice_t;
+
+typedef struct {
+    mp_obj_base_t base;
+    uint32_t* first_buffer;
+    uint32_t* second_buffer;
+    uint32_t len; // in words
+    uint8_t bits_per_sample;
+    bool use_first_buffer;
+    bool samples_signed;
+    uint8_t channel_count;
+    uint32_t sample_rate;
+
+    uint32_t read_count;
+    uint32_t left_read_count;
+    uint32_t right_read_count;
+
+    uint8_t voice_count;
+    audioio_mixer_voice_t voice[];
+} audioio_mixer_obj_t;
+
+
+// These are not available from Python because it may be called in an interrupt.
+void audioio_mixer_reset_buffer(audioio_mixer_obj_t* self,
+                                    bool single_channel,
+                                    uint8_t channel);
+audioio_get_buffer_result_t audioio_mixer_get_buffer(audioio_mixer_obj_t* self,
+                                                         bool single_channel,
+                                                         uint8_t channel,
+                                                         uint8_t** buffer,
+                                                         uint32_t* buffer_length); // length in bytes
+void audioio_mixer_get_buffer_structure(audioio_mixer_obj_t* self, bool single_channel,
+                                            bool* single_buffer, bool* samples_signed,
+                                            uint32_t* max_buffer_length, uint8_t* spacing);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_MIXER_H
diff --git a/shared-module/audiocore/RawSample.c b/shared-module/audiocore/RawSample.c
new file mode 100644
index 000000000..d6bf3a567
--- /dev/null
+++ b/shared-module/audiocore/RawSample.c
@@ -0,0 +1,94 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/audiocore/RawSample.h"
+
+#include <stdint.h>
+
+#include "shared-module/audiocore/RawSample.h"
+
+void common_hal_audioio_rawsample_construct(audioio_rawsample_obj_t* self,
+                                            uint8_t* buffer,
+                                            uint32_t len,
+                                            uint8_t bytes_per_sample,
+                                            bool samples_signed,
+                                            uint8_t channel_count,
+                                            uint32_t sample_rate) {
+    self->buffer = buffer;
+    self->bits_per_sample = bytes_per_sample * 8;
+    self->samples_signed = samples_signed;
+    self->len = len;
+    self->channel_count = channel_count;
+    self->sample_rate = sample_rate;
+    self->buffer_read = false;
+}
+
+void common_hal_audioio_rawsample_deinit(audioio_rawsample_obj_t* self) {
+    self->buffer = NULL;
+}
+bool common_hal_audioio_rawsample_deinited(audioio_rawsample_obj_t* self) {
+    return self->buffer == NULL;
+}
+
+uint32_t common_hal_audioio_rawsample_get_sample_rate(audioio_rawsample_obj_t* self) {
+    return self->sample_rate;
+}
+void common_hal_audioio_rawsample_set_sample_rate(audioio_rawsample_obj_t* self,
+                                                  uint32_t sample_rate) {
+    self->sample_rate = sample_rate;
+}
+
+void audioio_rawsample_reset_buffer(audioio_rawsample_obj_t* self,
+                                    bool single_channel,
+                                    uint8_t channel) {
+}
+
+audioio_get_buffer_result_t audioio_rawsample_get_buffer(audioio_rawsample_obj_t* self,
+                                                         bool single_channel,
+                                                         uint8_t channel,
+                                                         uint8_t** buffer,
+                                                         uint32_t* buffer_length) {
+    *buffer_length = self->len;
+    if (single_channel) {
+        *buffer = self->buffer + (channel % self->channel_count) * (self->bits_per_sample / 8);
+    } else {
+        *buffer = self->buffer;
+    }
+    return GET_BUFFER_DONE;
+}
+
+void audioio_rawsample_get_buffer_structure(audioio_rawsample_obj_t* self, bool single_channel,
+                                            bool* single_buffer, bool* samples_signed,
+                                            uint32_t* max_buffer_length, uint8_t* spacing) {
+    *single_buffer = true;
+    *samples_signed = self->samples_signed;
+    *max_buffer_length = self->len;
+    if (single_channel) {
+        *spacing = self->channel_count;
+    } else {
+        *spacing = 1;
+    }
+}
diff --git a/shared-module/audiocore/RawSample.h b/shared-module/audiocore/RawSample.h
new file mode 100644
index 000000000..6c2c19c9b
--- /dev/null
+++ b/shared-module/audiocore/RawSample.h
@@ -0,0 +1,59 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_RAWSAMPLE_H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_RAWSAMPLE_H
+
+#include "py/obj.h"
+
+#include "shared-module/audiocore/__init__.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    uint8_t* buffer;
+    uint32_t len;
+    uint8_t bits_per_sample;
+    bool samples_signed;
+    uint8_t channel_count;
+    uint32_t sample_rate;
+    bool buffer_read;
+} audioio_rawsample_obj_t;
+
+
+// These are not available from Python because it may be called in an interrupt.
+void audioio_rawsample_reset_buffer(audioio_rawsample_obj_t* self,
+                                    bool single_channel,
+                                    uint8_t channel);
+audioio_get_buffer_result_t audioio_rawsample_get_buffer(audioio_rawsample_obj_t* self,
+                                                         bool single_channel,
+                                                         uint8_t channel,
+                                                         uint8_t** buffer,
+                                                         uint32_t* buffer_length); // length in bytes
+void audioio_rawsample_get_buffer_structure(audioio_rawsample_obj_t* self, bool single_channel,
+                                            bool* single_buffer, bool* samples_signed,
+                                            uint32_t* max_buffer_length, uint8_t* spacing);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_RAWSAMPLE_H
diff --git a/shared-module/audiocore/WaveFile.c b/shared-module/audiocore/WaveFile.c
new file mode 100644
index 000000000..810d9c33b
--- /dev/null
+++ b/shared-module/audiocore/WaveFile.c
@@ -0,0 +1,268 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/audiocore/WaveFile.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include "py/mperrno.h"
+#include "py/runtime.h"
+
+#include "shared-module/audiocore/WaveFile.h"
+#include "supervisor/shared/translate.h"
+
+struct wave_format_chunk {
+    uint16_t audio_format;
+    uint16_t num_channels;
+    uint32_t sample_rate;
+    uint32_t byte_rate;
+    uint16_t block_align;
+    uint16_t bits_per_sample;
+    uint16_t extra_params; // Assumed to be zero below.
+};
+
+void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
+                                           pyb_file_obj_t* file) {
+    // Load the wave
+    self->file = file;
+    uint8_t chunk_header[16];
+    f_rewind(&self->file->fp);
+    UINT bytes_read;
+    if (f_read(&self->file->fp, chunk_header, 16, &bytes_read) != FR_OK) {
+        mp_raise_OSError(MP_EIO);
+    }
+    if (bytes_read != 16 ||
+        memcmp(chunk_header, "RIFF", 4) != 0 ||
+        memcmp(chunk_header + 8, "WAVEfmt ", 8) != 0) {
+        mp_raise_ValueError(translate("Invalid wave file"));
+    }
+    uint32_t format_size;
+    if (f_read(&self->file->fp, &format_size, 4, &bytes_read) != FR_OK) {
+        mp_raise_OSError(MP_EIO);
+    }
+    if (bytes_read != 4 ||
+        format_size > sizeof(struct wave_format_chunk)) {
+        mp_raise_ValueError(translate("Invalid format chunk size"));
+    }
+    struct wave_format_chunk format;
+    if (f_read(&self->file->fp, &format, format_size, &bytes_read) != FR_OK) {
+        mp_raise_OSError(MP_EIO);
+    }
+    if (bytes_read != format_size) {
+    }
+
+    if (format.audio_format != 1 ||
+        format.num_channels > 2 ||
+        format.bits_per_sample > 16 ||
+        (format_size == 18 &&
+         format.extra_params != 0)) {
+        mp_raise_ValueError(translate("Unsupported format"));
+    }
+    // Get the sample_rate
+    self->sample_rate = format.sample_rate;
+    self->len = 256;
+    self->channel_count = format.num_channels;
+    self->bits_per_sample = format.bits_per_sample;
+
+    // TODO(tannewt): Skip any extra chunks that occur before the data section.
+
+    uint8_t data_tag[4];
+    if (f_read(&self->file->fp, &data_tag, 4, &bytes_read) != FR_OK) {
+        mp_raise_OSError(MP_EIO);
+    }
+    if (bytes_read != 4 ||
+        memcmp((uint8_t *) data_tag, "data", 4) != 0) {
+        mp_raise_ValueError(translate("Data chunk must follow fmt chunk"));
+    }
+
+    uint32_t data_length;
+    if (f_read(&self->file->fp, &data_length, 4, &bytes_read) != FR_OK) {
+        mp_raise_OSError(MP_EIO);
+    }
+    if (bytes_read != 4) {
+        mp_raise_ValueError(translate("Invalid file"));
+    }
+    self->file_length = data_length;
+    self->data_start = self->file->fp.fptr;
+
+    // Try to allocate two buffers, one will be loaded from file and the other
+    // DMAed to DAC.
+    self->buffer = m_malloc(self->len, false);
+    if (self->buffer == NULL) {
+        common_hal_audioio_wavefile_deinit(self);
+        mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate first buffer"));
+    }
+
+    self->second_buffer = m_malloc(self->len, false);
+    if (self->second_buffer == NULL) {
+        common_hal_audioio_wavefile_deinit(self);
+        mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate second buffer"));
+    }
+}
+
+void common_hal_audioio_wavefile_deinit(audioio_wavefile_obj_t* self) {
+    self->buffer = NULL;
+}
+
+bool common_hal_audioio_wavefile_deinited(audioio_wavefile_obj_t* self) {
+    return self->buffer == NULL;
+}
+
+uint32_t common_hal_audioio_wavefile_get_sample_rate(audioio_wavefile_obj_t* self) {
+    return self->sample_rate;
+}
+
+void common_hal_audioio_wavefile_set_sample_rate(audioio_wavefile_obj_t* self,
+                                                 uint32_t sample_rate) {
+    self->sample_rate = sample_rate;
+}
+
+uint8_t common_hal_audioio_wavefile_get_bits_per_sample(audioio_wavefile_obj_t* self) {
+    return self->bits_per_sample;
+}
+
+uint8_t common_hal_audioio_wavefile_get_channel_count(audioio_wavefile_obj_t* self) {
+    return self->channel_count;
+}
+
+bool audioio_wavefile_samples_signed(audioio_wavefile_obj_t* self) {
+    return self->bits_per_sample > 8;
+}
+
+uint32_t audioio_wavefile_max_buffer_length(audioio_wavefile_obj_t* self) {
+    return 512;
+}
+
+void audioio_wavefile_reset_buffer(audioio_wavefile_obj_t* self,
+                                   bool single_channel,
+                                   uint8_t channel) {
+    if (single_channel && channel == 1) {
+        return;
+    }
+    // We don't reset the buffer index in case we're looping and we have an odd number of buffer
+    // loads
+    self->bytes_remaining = self->file_length;
+    f_lseek(&self->file->fp, self->data_start);
+    self->read_count = 0;
+    self->left_read_count = 0;
+    self->right_read_count = 0;
+}
+
+audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t* self,
+                                                        bool single_channel,
+                                                        uint8_t channel,
+                                                        uint8_t** buffer,
+                                                        uint32_t* buffer_length) {
+    if (!single_channel) {
+        channel = 0;
+    }
+
+    uint32_t channel_read_count = self->left_read_count;
+    if (channel == 1) {
+        channel_read_count = self->right_read_count;
+    }
+
+    bool need_more_data = self->read_count == channel_read_count;
+
+    if (self->bytes_remaining == 0 && need_more_data) {
+        *buffer = NULL;
+        *buffer_length = 0;
+        return GET_BUFFER_DONE;
+    }
+
+    if (need_more_data) {
+        uint16_t num_bytes_to_load = self->len;
+        if (num_bytes_to_load > self->bytes_remaining) {
+            num_bytes_to_load = self->bytes_remaining;
+        }
+        UINT length_read;
+        if (self->buffer_index % 2 == 1) {
+            *buffer = self->second_buffer;
+        } else {
+            *buffer = self->buffer;
+        }
+        if (f_read(&self->file->fp, *buffer, num_bytes_to_load, &length_read) != FR_OK) {
+            return GET_BUFFER_ERROR;
+        }
+        self->bytes_remaining -= length_read;
+        // Pad the last buffer to word align it.
+        if (self->bytes_remaining == 0 && length_read % sizeof(uint32_t) != 0) {
+            uint32_t pad = length_read % sizeof(uint32_t);
+            length_read += pad;
+            if (self->bits_per_sample == 8) {
+                for (uint32_t i = 0; i < pad; i++) {
+                    ((uint8_t*) (*buffer))[length_read / sizeof(uint8_t) - i - 1] = 0x80;
+                }
+            } else if (self->bits_per_sample == 16) {
+                // We know the buffer is aligned because we allocated it onto the heap ourselves.
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wcast-align"
+                ((int16_t*) (*buffer))[length_read / sizeof(int16_t) - 1] = 0;
+                #pragma GCC diagnostic pop
+            }
+        }
+        *buffer_length = length_read;
+        if (self->buffer_index % 2 == 1) {
+            self->second_buffer_length = length_read;
+        } else {
+            self->buffer_length = length_read;
+        }
+        self->buffer_index += 1;
+        self->read_count += 1;
+    }
+
+    uint32_t buffers_back = self->read_count - 1 - channel_read_count;
+    if ((self->buffer_index - buffers_back) % 2 == 0) {
+        *buffer = self->second_buffer;
+        *buffer_length = self->second_buffer_length;
+    } else {
+        *buffer = self->buffer;
+        *buffer_length = self->buffer_length;
+    }
+
+    if (channel == 0) {
+        self->left_read_count += 1;
+    } else if (channel == 1) {
+        self->right_read_count += 1;
+        *buffer = *buffer + self->bits_per_sample / 8;
+    }
+
+    return self->bytes_remaining == 0 ? GET_BUFFER_DONE : GET_BUFFER_MORE_DATA;
+}
+
+void audioio_wavefile_get_buffer_structure(audioio_wavefile_obj_t* self, bool single_channel,
+                                           bool* single_buffer, bool* samples_signed,
+                                           uint32_t* max_buffer_length, uint8_t* spacing) {
+    *single_buffer = false;
+    *samples_signed = self->bits_per_sample > 8;
+    *max_buffer_length = 512;
+    if (single_channel) {
+        *spacing = self->channel_count;
+    } else {
+        *spacing = 1;
+    }
+}
diff --git a/shared-module/audiocore/WaveFile.h b/shared-module/audiocore/WaveFile.h
new file mode 100644
index 000000000..97dd6a46f
--- /dev/null
+++ b/shared-module/audiocore/WaveFile.h
@@ -0,0 +1,70 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_WAVEFILE_H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_WAVEFILE_H
+
+#include "py/obj.h"
+
+#include "shared-module/audiocore/__init__.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    uint8_t* buffer;
+    uint32_t buffer_length;
+    uint8_t* second_buffer;
+    uint32_t second_buffer_length;
+    uint32_t file_length; // In bytes
+    uint16_t data_start; // Where the data values start
+    uint8_t bits_per_sample;
+    uint16_t buffer_index;
+    uint32_t bytes_remaining;
+
+    uint8_t channel_count;
+    uint32_t sample_rate;
+
+    uint32_t len;
+    pyb_file_obj_t* file;
+
+    uint32_t read_count;
+    uint32_t left_read_count;
+    uint32_t right_read_count;
+} audioio_wavefile_obj_t;
+
+// These are not available from Python because it may be called in an interrupt.
+void audioio_wavefile_reset_buffer(audioio_wavefile_obj_t* self,
+                                   bool single_channel,
+                                   uint8_t channel);
+audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t* self,
+                                                        bool single_channel,
+                                                        uint8_t channel,
+                                                        uint8_t** buffer,
+                                                        uint32_t* buffer_length); // length in bytes
+void audioio_wavefile_get_buffer_structure(audioio_wavefile_obj_t* self, bool single_channel,
+                                           bool* single_buffer, bool* samples_signed,
+                                           uint32_t* max_buffer_length, uint8_t* spacing);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_WAVEFILE_H
diff --git a/shared-module/audiocore/__init__.c b/shared-module/audiocore/__init__.c
new file mode 100644
index 000000000..067cae5dd
--- /dev/null
+++ b/shared-module/audiocore/__init__.c
@@ -0,0 +1,125 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-module/audioio/__init__.h"
+
+#include "py/obj.h"
+#include "shared-bindings/audiocore/Mixer.h"
+#include "shared-bindings/audiocore/RawSample.h"
+#include "shared-bindings/audiocore/WaveFile.h"
+#include "shared-module/audiocore/Mixer.h"
+#include "shared-module/audiocore/RawSample.h"
+#include "shared-module/audiocore/WaveFile.h"
+
+uint32_t audiosample_sample_rate(mp_obj_t sample_obj) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return sample->sample_rate;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return file->sample_rate;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->sample_rate;
+    }
+    return 16000;
+}
+
+uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return sample->bits_per_sample;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return file->bits_per_sample;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->bits_per_sample;
+    }
+    return 8;
+}
+
+uint8_t audiosample_channel_count(mp_obj_t sample_obj) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return sample->channel_count;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return file->channel_count;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->channel_count;
+    }
+    return 1;
+}
+
+void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        audioio_rawsample_reset_buffer(sample, single_channel, audio_channel);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_wavefile_reset_buffer(file, single_channel, audio_channel);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_mixer_reset_buffer(file, single_channel, audio_channel);
+    }
+}
+
+audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
+                                                   bool single_channel,
+                                                   uint8_t channel,
+                                                   uint8_t** buffer, uint32_t* buffer_length) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return audioio_rawsample_get_buffer(sample, single_channel, channel, buffer, buffer_length);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return audioio_wavefile_get_buffer(file, single_channel, channel, buffer, buffer_length);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return audioio_mixer_get_buffer(file, single_channel, channel, buffer, buffer_length);
+    }
+    return GET_BUFFER_DONE;
+}
+
+void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
+                                      bool* single_buffer, bool* samples_signed,
+                                      uint32_t* max_buffer_length, uint8_t* spacing) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        audioio_rawsample_get_buffer_structure(sample, single_channel, single_buffer,
+                                               samples_signed, max_buffer_length, spacing);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_wavefile_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
+                                              max_buffer_length, spacing);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_mixer_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
+                                              max_buffer_length, spacing);
+    }
+}
diff --git a/shared-module/audiocore/__init__.h b/shared-module/audiocore/__init__.h
new file mode 100644
index 000000000..7aa0c1824
--- /dev/null
+++ b/shared-module/audiocore/__init__.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOCORE__INIT__H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOCORE__INIT__H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "py/obj.h"
+
+typedef enum {
+    GET_BUFFER_DONE,            // No more data to read
+    GET_BUFFER_MORE_DATA,       // More data to read.
+    GET_BUFFER_ERROR,           // Error while reading data.
+} audioio_get_buffer_result_t;
+
+uint32_t audiosample_sample_rate(mp_obj_t sample_obj);
+uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj);
+uint8_t audiosample_channel_count(mp_obj_t sample_obj);
+void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel);
+audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
+                                                   bool single_channel,
+                                                   uint8_t channel,
+                                                   uint8_t** buffer, uint32_t* buffer_length);
+void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
+                                      bool* single_buffer, bool* samples_signed,
+                                      uint32_t* max_buffer_length, uint8_t* spacing);
+
+#endif  // MICROPY_INCLUDED_SHARED_MODULE_AUDIOCORE__INIT__H