Working on audio playback

Audio players are displayed the same way as images. When playing, a decoder runs in a background thread producing samples suitable for output.

8 files changed, 524 insertions, 101 deletions

diff --git a/src/audio/player.c b/src/audio/player.c
index aea2a998..1dd3c38a 100644
--- a/src/audio/player.c
+++ b/src/audio/player.c
@@ -22,12 +22,122 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 
 #include "player.h"
 
+#include <the_Foundation/buffer.h>
 #include <the_Foundation/thread.h>
 #include <SDL_audio.h>
 
+iDeclareType(InputBuf)
+
+struct Impl_InputBuf {
+    iMutex     mtx;
+    iCondition changed;
+    iBlock     data;
+    iBool      isComplete;
+};
+
+void init_InputBuf(iInputBuf *d) {
+    init_Mutex(&d->mtx);
+    init_Condition(&d->changed);
+    init_Block(&d->data, 0);
+    d->isComplete = iTrue;
+}
+
+void deinit_InputBuf(iInputBuf *d) {
+    deinit_Block(&d->data);
+    deinit_Condition(&d->changed);
+    deinit_Mutex(&d->mtx);
+}
+
+size_t size_InputBuf(const iInputBuf *d) {
+    return size_Block(&d->data);
+}
+
+iDefineTypeConstruction(InputBuf)
+
+/*----------------------------------------------------------------------------------------------*/
+
+iDeclareType(SampleBuf)
+
+struct Impl_SampleBuf {
+    void * data;
+    size_t sampleSize;
+    size_t count;
+    size_t head, tail;
+};
+
+void init_SampleBuf(iSampleBuf *d, size_t sampleSize, size_t count) {
+    d->sampleSize = sampleSize;
+    d->count      = count + 1; /* considered empty if head==tail */
+    d->data       = malloc(d->sampleSize * d->count);
+    d->head       = 0;
+    d->tail       = 0;
+}
+
+void deinit_SampleBuf(iSampleBuf *d) {
+    free(d->data);
+}
+
+size_t size_SampleBuf(const iSampleBuf *d) {
+    return d->head - d->tail;
+}
+
+size_t vacancy_SampleBuf(const iSampleBuf *d) {
+    return d->count - size_SampleBuf(d) - 1;
+}
+
+iBool isFull_SampleBuf(const iSampleBuf *d) {
+    return vacancy_SampleBuf(d) == 0;
+}
+
+iLocalDef void *ptr_SampleBuf_(iSampleBuf *d, size_t pos) {
+    return ((char *) d->data) + (d->sampleSize * pos);
+}
+
+void write_SampleBuf(iSampleBuf *d, const void *samples, const size_t n) {
+    iAssert(n <= vacancy_SampleBuf(d));
+    const size_t headPos = d->head % d->count;
+    const size_t avail   = d->count - headPos;
+    if (n > avail) {
+        const char *in = samples;
+        memcpy(ptr_SampleBuf_(d, headPos), in, d->sampleSize * avail);
+        in += d->sampleSize * avail;
+        memcpy(ptr_SampleBuf_(d, 0), in, d->sampleSize * (n - avail));
+    }
+    else {
+        memcpy(ptr_SampleBuf_(d, headPos), samples, d->sampleSize * n);
+    }
+    d->head += n;
+}
+
+void read_SampleBuf(iSampleBuf *d, const size_t n, void *samples_out) {
+    iAssert(n <= size_SampleBuf(d));
+    const size_t tailPos = d->tail % d->count;
+    const size_t avail   = d->count - tailPos;
+    if (n > avail) {
+        char *out = samples_out;
+        memcpy(out, ptr_SampleBuf_(d, tailPos), d->sampleSize * avail);
+        out += d->sampleSize * avail;
+        memcpy(out, ptr_SampleBuf_(d, 0), d->sampleSize * (n - avail));
+    }
+    else {
+        memcpy(samples_out, ptr_SampleBuf_(d, tailPos), d->sampleSize * n);
+    }
+    d->tail += n;
+}
+
+/*----------------------------------------------------------------------------------------------*/
+
+iDeclareType(ContentSpec)
+
+struct Impl_ContentSpec {
+    SDL_AudioSpec spec;
+    iRanges       wavData;
+};
+
 iDeclareType(Decoder)
 
 enum iDecoderType {
+    none_DecoderType,
     wav_DecoderType,
     mpeg_DecoderType,
     vorbis_DecoderType,
@@ -36,29 +146,189 @@ enum iDecoderType {
 
 struct Impl_Decoder {
     enum iDecoderType type;
-    size_t inPos;
-//    iBlock samples;
+    iThread *         thread;
+    iInputBuf *       input;
+    size_t            inputPos;
+    iSampleBuf        output;
+    iMutex            mtx; /* for output */
+    iRanges           wavData;
 };
 
+static void parseWav_Decoder_(iDecoder *d, iRanges inputRange) {
+    lock_Mutex(&d->mtx);
+    const size_t vacancy = vacancy_SampleBuf(&d->output);
+    const size_t avail = iMin(inputRange.end - d->inputPos, d->wavData.end - d->inputPos) /
+                         d->output.sampleSize;
+    const size_t n = iMin(vacancy, avail);
+    iGuardMutex(&d->input->mtx, /* lock so input array isn't reallocated during the copy */
+                write_SampleBuf(&d->output, constData_Block(&d->input->data) + d->inputPos, n));
+    d->inputPos += n;
+    unlock_Mutex(&d->mtx);
+}
+
+static iThreadResult run_Decoder_(iThread *thread) {
+    iDecoder *d = userData_Thread(thread);
+    while (d->type) {
+        size_t inputSize = 0;
+        /* Grab more input. */ {
+            lock_Mutex(&d->input->mtx);
+            wait_Condition(&d->input->changed, &d->input->mtx);
+            inputSize = size_Block(&d->input->data);
+            unlock_Mutex(&d->input->mtx);
+        }
+        iRanges inputRange = { d->inputPos, inputSize };
+        iAssert(inputRange.start <= inputRange.end);
+        if (!d->type) break;
+        /* Have data to work on and a place to save output? */
+        if (!isEmpty_Range(&inputRange) && !isFull_SampleBuf(&d->output)) {
+            switch (d->type) {
+                case wav_DecoderType:
+                    parseWav_Decoder_(d, inputRange);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    return 0;
+}
+
+void init_Decoder(iDecoder *d, iInputBuf *input, const iContentSpec *spec) {
+    d->type     = wav_DecoderType;
+    d->input    = input;
+    d->inputPos = spec->wavData.start;
+    init_SampleBuf(&d->output, SDL_AUDIO_BITSIZE(spec->spec.format) / 8 *
+                                   spec->spec.channels, spec->spec.samples * 2);
+    init_Mutex(&d->mtx);
+    d->thread = new_Thread(run_Decoder_);
+    setUserData_Thread(d->thread, d);
+    start_Thread(d->thread);
+}
+
+void deinit_Decoder(iDecoder *d) {
+    d->type = none_DecoderType;
+    signal_Condition(&d->input->changed);
+    join_Thread(d->thread);
+    iRelease(d->thread);
+    deinit_Mutex(&d->mtx);
+    deinit_SampleBuf(&d->output);
+}
+
+iDefineTypeConstructionArgs(Decoder, (iInputBuf *input, const iContentSpec *spec),
+                            input, spec)
+
+/*----------------------------------------------------------------------------------------------*/
+
 struct Impl_Player {
     SDL_AudioSpec spec;
     SDL_AudioDeviceID device;
-    iMutex mtx;
-    iBlock data;
-    iBool isDataComplete;
+    iInputBuf *data;
+    iDecoder *decoder;
 };
 
+iDefineTypeConstruction(Player)
+
+static size_t sampleSize_Player_(const iPlayer *d) {
+    return d->spec.channels * SDL_AUDIO_BITSIZE(d->spec.format) / 8;
+}
+
+static int silence_Player_(const iPlayer *d) {
+    return d->spec.silence;
+}
+
+static iContentSpec contentSpec_Player_(const iPlayer *d) {
+    iContentSpec content;
+    iZap(content);
+    const size_t dataSize = size_InputBuf(d->data);
+    iBuffer *buf = iClob(new_Buffer());
+    open_Buffer(buf, &d->data->data);
+    enum iDecoderType decType = wav_DecoderType; /* TODO: from MIME */
+    if (decType == wav_DecoderType && dataSize >= 44) {
+        /* Read the RIFF/WAVE header. */
+        iStream *is = stream_Buffer(buf);
+        char magic[4];
+        readData_Buffer(buf, 4, magic);
+        if (memcmp(magic, "RIFF", 4)) {
+            /* Not WAV. */
+            return content;
+        }
+        readU32_Stream(is); /* file size */
+        readData_Buffer(buf, 4, magic);
+        if (memcmp(magic, "WAVE", 4)) {
+            /* Not WAV. */
+            return content;
+        }
+        /* Read all the chunks. */
+        while (!atEnd_Buffer(buf)) {
+            readData_Buffer(buf, 4, magic);
+            const size_t size = read32_Stream(is);
+            if (memcmp(magic, "fmt ", 4) == 0) {
+                if (size != 16) {
+                    return content;
+                }
+                const int16_t  mode           = read16_Stream(is); /* 1 = PCM */
+                const int16_t  numChannels    = read16_Stream(is);
+                const int32_t  freq           = read32_Stream(is);
+                const uint32_t bytesPerSecond = readU32_Stream(is);
+                const int16_t  blockAlign     = read16_Stream(is);
+                const int16_t  bitsPerSample  = read16_Stream(is);
+                iUnused(bytesPerSecond);
+                iUnused(blockAlign); /* TODO: Should use this one when reading samples? */
+                if (mode != 1) { /* PCM */
+                    return content;
+                }
+                if (numChannels != 1 && numChannels != 2) {
+                    return content;
+                }
+                if (bitsPerSample != 8 && bitsPerSample != 16 && bitsPerSample != 32) {
+                    return content;
+                }
+                content.spec.freq     = freq;
+                content.spec.channels = numChannels;
+                content.spec.format =
+                    (bitsPerSample == 8 ? AUDIO_S8 : bitsPerSample == 16 ? AUDIO_S16 : AUDIO_S32);
+            }
+            else if (memcmp(magic, "data", 4) == 0) {
+                size_t len = read32_Stream(is); /* data size */
+                content.wavData = (iRanges){ pos_Stream(is), pos_Stream(is) + len };
+                break;
+            }
+            else {
+                seek_Stream(is, pos_Stream(is) + size);
+            }
+        }
+    }
+    content.spec.samples = 2048;
+    return content;
+}
+
+static void writeOutputSamples_Player_(void *plr, Uint8 *stream, int len) {
+    iPlayer *d = plr;
+    iAssert(d->decoder);
+    const size_t sampleSize = sampleSize_Player_(d);
+    const size_t count      = len / sampleSize;
+    lock_Mutex(&d->decoder->mtx);
+    if (size_SampleBuf(&d->decoder->output) >= count) {
+        read_SampleBuf(&d->decoder->output, count, stream);
+    }
+    else {
+        memset(stream, 0, len); /* TODO: If unsigned samples, don't use zero! */
+    }
+    unlock_Mutex(&d->decoder->mtx);
+    /* Wake up decoder; there is more room for output. */
+    signal_Condition(&d->data->changed);
+}
+
 void init_Player(iPlayer *d) {
     iZap(d->spec);
-    d->device = 0;
-    init_Mutex(&d->mtx);
-    init_Block(&d->data, 0);
-    d->isDataComplete = iFalse;
+    d->device  = 0;
+    d->decoder = NULL;
+    d->data    = new_InputBuf();
 }
 
 void deinit_Player(iPlayer *d) {
     stop_Player(d);
-    deinit_Block(&d->data);
+    delete_InputBuf(d->data);
 }
 
 iBool isStarted_Player(const iPlayer *d) {
@@ -70,55 +340,54 @@ void setFormatHint_Player(iPlayer *d, const char *hint) {
 }
 
 void updateSourceData_Player(iPlayer *d, const iBlock *data, enum iPlayerUpdate update) {
-    lock_Mutex(&d->mtx);
+    iInputBuf *inp = d->data;
+    lock_Mutex(&inp->mtx);
     switch (update) {
         case replace_PlayerUpdate:
-            set_Block(&d->data, data);
-            d->isDataComplete = iFalse;
+            set_Block(&inp->data, data);
+            inp->isComplete = iFalse;
             break;
         case append_PlayerUpdate:
-            append_Block(&d->data, data);
-            d->isDataComplete = iFalse;
+            append_Block(&inp->data, data);
+            inp->isComplete = iFalse;
             break;
         case complete_PlayerUpdate:
-            d->isDataComplete = iTrue;
+            inp->isComplete = iTrue;
             break;
     }
-    unlock_Mutex(&d->mtx);
-}
-
-static void writeOutputSamples_Player_(void *plr, Uint8 *stream, int len) {
-    iPlayer *d = plr;
-    memset(stream, 0, len);
-    /* TODO: Copy samples from the decoder's ring buffer. */
+    signal_Condition(&inp->changed);
+    unlock_Mutex(&inp->mtx);
 }
 
 iBool start_Player(iPlayer *d) {
     if (isStarted_Player(d)) {
         return iFalse;
     }
-    SDL_AudioSpec conf;
-    iZap(conf);
-    conf.freq     = 44100; /* TODO: from content */
-    conf.format   = AUDIO_S16;
-    conf.channels = 2; /* TODO: from content */
-    conf.samples  = 2048;
-    conf.callback = writeOutputSamples_Player_;
-    conf.userdata = d;
-    d->device     = SDL_OpenAudioDevice(NULL, SDL_FALSE /* playback */, &conf, &d->spec, 0);
+    iContentSpec content  = contentSpec_Player_(d);
+    content.spec.callback = writeOutputSamples_Player_;
+    content.spec.userdata = d;
+    d->device = SDL_OpenAudioDevice(NULL, SDL_FALSE /* playback */, &content.spec, &d->spec, 0);
     if (!d->device) {
         return iFalse;
     }
-    /* TODO: Start the stream/decoder thread. */
-    /* TODO: Audio device is unpaused when there are samples ready to play. */
+    d->decoder = new_Decoder(d->data, &content);
+    SDL_PauseAudioDevice(d->device, SDL_FALSE);
     return iTrue;
 }
 
+void setPaused_Player(iPlayer *d, iBool isPaused) {
+    if (isStarted_Player(d)) {
+        SDL_PauseAudioDevice(d->device, isPaused ? SDL_TRUE : SDL_FALSE);
+    }
+}
+
 void stop_Player(iPlayer *d) {
     if (isStarted_Player(d)) {
         /* TODO: Stop the stream/decoder. */
         SDL_PauseAudioDevice(d->device, SDL_TRUE);
         SDL_CloseAudioDevice(d->device);
         d->device = 0;
+        delete_Decoder(d->decoder);
+        d->decoder = NULL;
     }
 }
diff --git a/src/audio/player.h b/src/audio/player.h
index 121659f2..2138c556 100644
--- a/src/audio/player.h
+++ b/src/audio/player.h
@@ -36,7 +36,8 @@ enum iPlayerUpdate {
 void    setFormatHint_Player    (iPlayer *, const char *hint);
 void    updateSourceData_Player (iPlayer *, const iBlock *data, enum iPlayerUpdate update);
 
-iBool   start_Player    (iPlayer *);
-void    stop_Player     (iPlayer *);
+iBool   start_Player        (iPlayer *);
+void    setPaused_Player    (iPlayer *, iBool isPaused);
+void    stop_Player         (iPlayer *);
 
 iBool   isStarted_Player    (const iPlayer *);
diff --git a/src/gmdocument.c b/src/gmdocument.c
index 6e139e45..ff0e019b 100644
--- a/src/gmdocument.c
+++ b/src/gmdocument.c
@@ -308,6 +308,7 @@ static void doLayout_GmDocument_(iGmDocument *d) {
         run.color = white_ColorId;
         run.linkId = 0;
         run.imageId = 0;
+        run.audioId = 0;
         enum iGmLineType type;
         int indent = 0;
         /* Detect the type of the line. */
@@ -429,12 +430,12 @@ static void doLayout_GmDocument_(iGmDocument *d) {
         }
         /* Quote icon. */
         if (type == quote_GmLineType && addQuoteIcon) {
-            addQuoteIcon = iFalse;
+            addQuoteIcon    = iFalse;
             iGmRun quoteRun = run;
-            quoteRun.font           = heading1_FontId;
-            quoteRun.text           = range_CStr(quote);
-            quoteRun.color          = tmQuoteIcon_ColorId;
-            iRect vis = visualBounds_Text(quoteRun.font, quoteRun.text);
+            quoteRun.font   = heading1_FontId;
+            quoteRun.text   = range_CStr(quote);
+            quoteRun.color  = tmQuoteIcon_ColorId;
+            iRect vis       = visualBounds_Text(quoteRun.font, quoteRun.text);
             quoteRun.visBounds.size = advance_Text(quoteRun.font, quote);
             quoteRun.visBounds.pos =
                 add_I2(pos,
@@ -522,6 +523,7 @@ static void doLayout_GmDocument_(iGmDocument *d) {
         /* Image content. */
         if (type == link_GmLineType) {
             const iMediaId imageId = findLinkImage_Media(d->media, run.linkId);
+            const iMediaId audioId = !imageId ? findLinkAudio_Media(d->media, run.linkId) : 0;
             if (imageId) {
                 iGmImageInfo img;
                 imageInfo_Media(d->media, imageId, &img);
@@ -532,7 +534,7 @@ static void doLayout_GmDocument_(iGmDocument *d) {
                         link->flags |= permanent_GmLinkFlag;
                     }
                 }
-                const int margin = 0.5f * lineHeight_Text(paragraph_FontId);
+                const int margin = lineHeight_Text(paragraph_FontId) / 2;
                 pos.y += margin;
                 run.bounds.pos = pos;
                 run.bounds.size.x = d->size.x;
@@ -554,6 +556,28 @@ static void doLayout_GmDocument_(iGmDocument *d) {
                 pushBack_Array(&d->layout, &run);
                 pos.y += run.bounds.size.y + margin;
             }
+            else if (audioId) {
+                iGmAudioInfo info;
+                audioInfo_Media(d->media, audioId, &info);
+                /* Mark the link as having content. */ {
+                    iGmLink *link = at_PtrArray(&d->links, run.linkId - 1);
+                    link->flags |= content_GmLinkFlag;
+                    if (info.isPermanent) {
+                        link->flags |= permanent_GmLinkFlag;
+                    }
+                }
+                const int margin = lineHeight_Text(paragraph_FontId) / 2;
+                pos.y += margin;
+                run.bounds.pos    = pos;
+                run.bounds.size.x = d->size.x;
+                run.bounds.size.y = 2 * lineHeight_Text(uiContent_FontId);
+                run.visBounds     = run.bounds;
+                run.text          = iNullRange;
+                run.color         = 0;
+                run.audioId       = audioId;
+                pushBack_Array(&d->layout, &run);
+                pos.y += run.bounds.size.y + margin;
+            }
         }
         prevType = type;
     }
@@ -1120,10 +1144,14 @@ const iTime *linkTime_GmDocument(const iGmDocument *d, iGmLinkId linkId) {
     return link ? &link->when : NULL;
 }
 
-uint16_t linkImage_GmDocument(const iGmDocument *d, iGmLinkId linkId) {
+iMediaId linkImage_GmDocument(const iGmDocument *d, iGmLinkId linkId) {
     return findLinkImage_Media(d->media, linkId);
 }
 
+iMediaId linkAudio_GmDocument(const iGmDocument *d, iGmLinkId linkId) {
+    return findLinkAudio_Media(d->media, linkId);
+}
+
 enum iColorId linkColor_GmDocument(const iGmDocument *d, iGmLinkId linkId, enum iGmLinkPart part) {
     const iGmLink *link = link_GmDocument_(d, linkId);
     const int www_GmLinkFlag = http_GmLinkFlag | mailto_GmLinkFlag;
diff --git a/src/gmdocument.h b/src/gmdocument.h
index a04398d9..19a6036f 100644
--- a/src/gmdocument.h
+++ b/src/gmdocument.h
@@ -132,7 +132,8 @@ const iGmRun *  findRun_GmDocument      (const iGmDocument *, iInt2 pos);
 const char *    findLoc_GmDocument      (const iGmDocument *, iInt2 pos);
 const iGmRun *  findRunAtLoc_GmDocument (const iGmDocument *, const char *loc);
 const iString * linkUrl_GmDocument      (const iGmDocument *, iGmLinkId linkId);
-uint16_t        linkImage_GmDocument    (const iGmDocument *, iGmLinkId linkId);
+iMediaId        linkImage_GmDocument    (const iGmDocument *, iGmLinkId linkId);
+iMediaId        linkAudio_GmDocument    (const iGmDocument *, iGmLinkId linkId);
 int             linkFlags_GmDocument    (const iGmDocument *, iGmLinkId linkId);
 enum iColorId   linkColor_GmDocument    (const iGmDocument *, iGmLinkId linkId, enum iGmLinkPart part);
 const iTime *   linkTime_GmDocument     (const iGmDocument *, iGmLinkId linkId);
diff --git a/src/gmrequest.c b/src/gmrequest.c
index b667c82a..161c654c 100644
--- a/src/gmrequest.c
+++ b/src/gmrequest.c
@@ -454,6 +454,9 @@ void submit_GmRequest(iGmRequest *d) {
             else if (endsWithCase_String(path, ".gif")) {
                 setCStr_String(&d->resp.meta, "image/gif");
             }
+            else if (endsWithCase_String(path, ".wav")) {
+                setCStr_String(&d->resp.meta, "audio/wave");
+            }
             else {
                 setCStr_String(&d->resp.meta, "application/octet-stream");
             }
diff --git a/src/media.c b/src/media.c
index 9f6acd19..5d88fbc4 100644
--- a/src/media.c
+++ b/src/media.c
@@ -23,26 +23,44 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 #include "media.h"
 #include "gmdocument.h"
 #include "ui/window.h"
+#include "audio/player.h"
 
 #include <the_Foundation/ptrarray.h>
 #include <stb_image.h>
 #include <SDL_hints.h>
 #include <SDL_render.h>
 
+iDeclareType(GmMediaProps)
+
+struct Impl_GmMediaProps {
+    iGmLinkId linkId;
+    iString   mime;
+    iBool     isPermanent;
+};
+
+static void init_GmMediaProps_(iGmMediaProps *d) {
+    d->linkId = 0;
+    init_String(&d->mime);
+    d->isPermanent = iFalse;
+}
+
+static void deinit_GmMediaProps_(iGmMediaProps *d) {
+    deinit_String(&d->mime);
+}
+
+/*----------------------------------------------------------------------------------------------*/
+
 iDeclareType(GmImage)
 
 struct Impl_GmImage {
+    iGmMediaProps props;
     iInt2        size;
     size_t       numBytes;
-    iString      mime;
-    iGmLinkId    linkId;
-    iBool        isPermanent;
     SDL_Texture *texture;
 };
 
 void init_GmImage(iGmImage *d, const iBlock *data) {
-    init_String(&d->mime);
-    d->isPermanent   = iFalse;
+    init_GmMediaProps_(&d->props);
     d->numBytes      = size_Block(data);
     uint8_t *imgData = stbi_load_from_memory(
         constData_Block(data), size_Block(data), &d->size.x, &d->size.y, NULL, 4);
@@ -60,30 +78,53 @@ void init_GmImage(iGmImage *d, const iBlock *data) {
         SDL_FreeSurface(surface);
         stbi_image_free(imgData);
     }
-    d->linkId = 0;
 }
 
 void deinit_GmImage(iGmImage *d) {
     SDL_DestroyTexture(d->texture);
-    deinit_String(&d->mime);
+    deinit_GmMediaProps_(&d->props);
 }
 
 iDefineTypeConstructionArgs(GmImage, (const iBlock *data), data)
 
 /*----------------------------------------------------------------------------------------------*/
 
+iDeclareType(GmAudio)
+
+struct Impl_GmAudio {
+    iGmMediaProps props;
+    iPlayer *player;
+};
+
+void init_GmAudio(iGmAudio *d) {
+    init_GmMediaProps_(&d->props);
+    d->player = new_Player();
+}
+
+void deinit_GmAudio(iGmAudio *d) {
+    delete_Player(d->player);
+    deinit_GmMediaProps_(&d->props);
+}
+
+iDefineTypeConstruction(GmAudio)
+
+/*----------------------------------------------------------------------------------------------*/
+
 struct Impl_Media {
     iPtrArray images;
+    iPtrArray audio;   
 };
 
 iDefineTypeConstruction(Media)
 
 void init_Media(iMedia *d) {
     init_PtrArray(&d->images);
+    init_PtrArray(&d->audio);
 }
 
 void deinit_Media(iMedia *d) {
     clear_Media(d);
+    deinit_PtrArray(&d->audio);
     deinit_PtrArray(&d->images);
 }
 
@@ -92,25 +133,35 @@ void clear_Media(iMedia *d) {
         deinit_GmImage(i.ptr);
     }
     clear_PtrArray(&d->images);
+    iForEach(PtrArray, a, &d->audio) {
+        deinit_GmAudio(a.ptr);
+    }
+    clear_PtrArray(&d->audio);
 }
 
-void setImage_Media(iMedia *d, iGmLinkId linkId, const iString *mime, const iBlock *data,
-                    iBool allowHide) {
+void setData_Media(iMedia *d, iGmLinkId linkId, const iString *mime, const iBlock *data,
+                   iBool allowHide) {
     if (!mime || !data) {
-        iGmImage *img;
-        const iMediaId existing = findLinkImage_Media(d, linkId);
+        iMediaId existing = findLinkImage_Media(d, linkId);
         if (existing) {
+            iGmImage *img;
             take_PtrArray(&d->images, existing - 1, (void **) &img);
             delete_GmImage(img);
         }
+        else if ((existing = findLinkAudio_Media(d, linkId)) != 0) {
+            iGmAudio *audio;
+            take_PtrArray(&d->audio, existing - 1, (void **) &audio);
+            delete_GmAudio(audio);
+        }
     }
     else {
-        /* TODO: check if we know this MIME type */
-        /* Upload the image. */ {
+        if (startsWith_String(mime, "image/")) {
+            /* Copy the image to a texture. */
+            /* TODO: Resize down to min(maximum texture size, window size). */
             iGmImage *img = new_GmImage(data);
-            img->linkId = linkId; /* TODO: use a hash? */
-            img->isPermanent = !allowHide;
-            set_String(&img->mime, mime);
+            img->props.linkId      = linkId; /* TODO: use a hash? */
+            img->props.isPermanent = !allowHide;
+            set_String(&img->props.mime, mime);
             if (img->texture) {
                 pushBack_PtrArray(&d->images, img);
             }
@@ -118,15 +169,34 @@ void setImage_Media(iMedia *d, iGmLinkId linkId, const iString *mime, const iBlo
                 delete_GmImage(img);
             }
         }
+        else if (startsWith_String(mime, "audio/")) {
+            iGmAudio *audio = new_GmAudio();
+            audio->props.linkId = linkId;
+            audio->props.isPermanent = !allowHide;
+            set_String(&audio->props.mime, mime);
+            /* TODO: What about update/complete, for streaming? */
+            updateSourceData_Player(audio->player, data, replace_PlayerUpdate);
+            pushBack_PtrArray(&d->audio, audio);
+        }
     }
-//    doLayout_GmDocument_(d);
 }
 
 iMediaId findLinkImage_Media(const iMedia *d, iGmLinkId linkId) {
     /* TODO: use a hash */
     iConstForEach(PtrArray, i, &d->images) {
         const iGmImage *img = i.ptr;
-        if (img->linkId == linkId) {
+        if (img->props.linkId == linkId) {
+            return index_PtrArrayConstIterator(&i) + 1;
+        }
+    }
+    return 0;
+}
+
+iMediaId findLinkAudio_Media(const iMedia *d, iGmLinkId linkId) {
+    /* TODO: use a hash */
+    iConstForEach(PtrArray, i, &d->audio) {
+        const iGmAudio *audio = i.ptr;
+        if (audio->props.linkId == linkId) {
             return index_PtrArrayConstIterator(&i) + 1;
         }
     }
@@ -141,15 +211,34 @@ SDL_Texture *imageTexture_Media(const iMedia *d, uint16_t imageId) {
     return NULL;
 }
 
-void imageInfo_Media(const iMedia *d, uint16_t imageId, iGmImageInfo *info_out) {
+iBool imageInfo_Media(const iMedia *d, iMediaId imageId, iGmImageInfo *info_out) {
     if (imageId > 0 && imageId <= size_PtrArray(&d->images)) {
         const iGmImage *img   = constAt_PtrArray(&d->images, imageId - 1);
         info_out->size        = img->size;
         info_out->numBytes    = img->numBytes;
-        info_out->mime        = cstr_String(&img->mime);
-        info_out->isPermanent = img->isPermanent;
+        info_out->mime        = cstr_String(&img->props.mime);
+        info_out->isPermanent = img->props.isPermanent;
+        return iTrue;
     }
-    else {
-        iZap(*info_out);
+    iZap(*info_out);
+    return iFalse;
+}
+
+iPlayer *audioData_Media(const iMedia *d, iMediaId audioId) {
+    if (audioId > 0 && audioId <= size_PtrArray(&d->audio)) {
+        const iGmAudio *audio = constAt_PtrArray(&d->audio, audioId - 1);
+        return audio->player;
+    }
+    return NULL;
+}
+
+iBool audioInfo_Media(const iMedia *d, iMediaId audioId, iGmAudioInfo *info_out) {
+    if (audioId > 0 && audioId <= size_PtrArray(&d->audio)) {
+        const iGmAudio *audio = constAt_PtrArray(&d->audio, audioId - 1);
+        info_out->mime        = cstr_String(&audio->props.mime);
+        info_out->isPermanent = audio->props.isPermanent;
+        return iTrue;
     }
+    iZap(*info_out);
+    return iFalse;
 }
diff --git a/src/media.h b/src/media.h
index 0a6c1a81..6f460422 100644
--- a/src/media.h
+++ b/src/media.h
@@ -29,20 +29,32 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 
 typedef uint16_t iMediaId;
 
+iDeclareType(Player)
 iDeclareType(GmImageInfo)
+iDeclareType(GmAudioInfo)
 
 struct Impl_GmImageInfo {
-    iInt2 size;
-    size_t numBytes;
+    iInt2       size;
+    size_t      numBytes;
     const char *mime;
-    iBool isPermanent;
+    iBool       isPermanent;
 };
 
-iDeclareType(Media) iDeclareTypeConstruction(Media)
+struct Impl_GmAudioInfo {
+    const char *mime;
+    iBool       isPermanent;
+};
+
+iDeclareType(Media)
+iDeclareTypeConstruction(Media)
 
 void    clear_Media     (iMedia *);
-void    setImage_Media  (iMedia *, uint16_t linkId, const iString *mime, const iBlock *data, iBool allowHide);
+void    setData_Media   (iMedia *, uint16_t linkId, const iString *mime, const iBlock *data, iBool allowHide);
 
 iMediaId        findLinkImage_Media (const iMedia *, uint16_t linkId);
+iBool           imageInfo_Media     (const iMedia *, iMediaId imageId, iGmImageInfo *info_out);
 SDL_Texture *   imageTexture_Media  (const iMedia *, iMediaId imageId);
-void            imageInfo_Media     (const iMedia *, iMediaId imageId, iGmImageInfo *info_out);
+
+iMediaId        findLinkAudio_Media (const iMedia *, uint16_t linkId);
+iBool           audioInfo_Media     (const iMedia *, iMediaId audioId, iGmAudioInfo *info_out);
+iPlayer *       audioPlayer_Media   (const iMedia *, iMediaId audioId);
diff --git a/src/ui/documentwidget.c b/src/ui/documentwidget.c
index f63d93f4..be9da513 100644
--- a/src/ui/documentwidget.c
+++ b/src/ui/documentwidget.c
@@ -723,24 +723,26 @@ static void updateDocument_DocumentWidget_(iDocumentWidget *d, const iGmResponse
                     docFormat = gemini_GmDocumentFormat;
                     setRange_String(&d->sourceMime, param);
                 }
-                else if (startsWith_Rangecc(param, "image/")) {
+                else if (startsWith_Rangecc(param, "image/") ||
+                         startsWith_Rangecc(param, "audio/")) {
                     docFormat = gemini_GmDocumentFormat;
                     setRange_String(&d->sourceMime, param);
                     if (!d->request || isFinished_GmRequest(d->request)) {
-                        /* Make a simple document with an image. */
-                        const char *imageTitle = "Image";
+                        /* Make a simple document with an image or audio player. */
+                        const char *linkTitle =
+                            startsWith_String(mimeStr, "image/") ? "Image" : "Audio";
                         iUrl parts;
                         init_Url(&parts, d->mod.url);
                         if (!isEmpty_Range(&parts.path)) {
-                            imageTitle =
+                            linkTitle =
                                 baseName_Path(collect_String(newRange_String(parts.path))).start;
                         }
-                        format_String(&str, "=> %s %s\n", cstr_String(d->mod.url), imageTitle);
-                        setImage_Media(media_GmDocument(d->doc),
-                                       1,
-                                       mimeStr,
-                                       &response->body,
-                                       iFalse /* it's fixed */);
+                        format_String(&str, "=> %s %s\n", cstr_String(d->mod.url), linkTitle);
+                        setData_Media(media_GmDocument(d->doc),
+                                      1,
+                                      mimeStr,
+                                      &response->body,
+                                      iFalse /* it's fixed */);
                         redoLayout_GmDocument(d->doc);
                     }
                     else {
@@ -1132,6 +1134,8 @@ static iBool handleMediaCommand_DocumentWidget_(iDocumentWidget *d, const char *
         return iFalse; /* not our request */
     }
     if (equal_Command(cmd, "media.updated")) {
+        /* Pass new data to media players. */
+
         /* Update the link's progress. */
         invalidateLink_DocumentWidget_(d, req->linkId);
         refresh_Widget(d);
@@ -1141,12 +1145,13 @@ static iBool handleMediaCommand_DocumentWidget_(iDocumentWidget *d, const char *
         const enum iGmStatusCode code = status_GmRequest(req->req);
         /* Give the media to the document for presentation. */
         if (code == success_GmStatusCode) {
-            if (startsWith_String(meta_GmRequest(req->req), "image/")) {
-                setImage_Media(media_GmDocument(d->doc),
-                               req->linkId,
-                               meta_GmRequest(req->req),
-                               body_GmRequest(req->req),
-                               iTrue);
+            if (startsWith_String(meta_GmRequest(req->req), "image/") ||
+                startsWith_String(meta_GmRequest(req->req), "audio/")) {
+                setData_Media(media_GmDocument(d->doc),
+                              req->linkId,
+                              meta_GmRequest(req->req),
+                              body_GmRequest(req->req),
+                              iTrue);
                 redoLayout_GmDocument(d->doc);
                 updateVisible_DocumentWidget_(d);
                 invalidate_DocumentWidget_(d);
@@ -1793,14 +1798,14 @@ static iBool processEvent_DocumentWidget_(iDocumentWidget *d, const SDL_Event *e
                     if (isMediaLink_GmDocument(d->doc, linkId)) {
                         const int linkFlags = linkFlags_GmDocument(d->doc, linkId);
                         if (linkFlags & content_GmLinkFlag && linkFlags & permanent_GmLinkFlag) {
-                            /* We have the image and it cannot be dismissed, so nothing
+                            /* We have the content and it cannot be dismissed, so nothing
                                further to do. */
                             return iTrue;
                         }
                         if (!requestMedia_DocumentWidget_(d, linkId)) {                            
                             if (linkFlags & content_GmLinkFlag) {
                                 /* Dismiss shown content on click. */
-                                setImage_Media(media_GmDocument(d->doc), linkId, NULL, NULL, iTrue);
+                                setData_Media(media_GmDocument(d->doc), linkId, NULL, NULL, iTrue);
                                 redoLayout_GmDocument(d->doc);
                                 d->hoverLink = NULL;
                                 scroll_DocumentWidget_(d, 0);
@@ -1813,11 +1818,11 @@ static iBool processEvent_DocumentWidget_(iDocumentWidget *d, const SDL_Event *e
                                 /* Show the existing content again if we have it. */
                                 iMediaRequest *req = findMediaRequest_DocumentWidget_(d, linkId);
                                 if (req) {
-                                    setImage_Media(media_GmDocument(d->doc),
-                                                   linkId,
-                                                   meta_GmRequest(req->req),
-                                                   body_GmRequest(req->req),
-                                                   iTrue);
+                                    setData_Media(media_GmDocument(d->doc),
+                                                  linkId,
+                                                  meta_GmRequest(req->req),
+                                                  body_GmRequest(req->req),
+                                                  iTrue);
                                     redoLayout_GmDocument(d->doc);
                                     updateVisible_DocumentWidget_(d);
                                     invalidate_DocumentWidget_(d);
@@ -1913,6 +1918,11 @@ static void drawRun_DrawContext_(void *context, const iGmRun *run) {
         }
         return;
     }
+    else if (run->audioId) {
+        /* Draw the audio player interface. */
+        fillRect_Paint(&d->paint, moved_Rect(run->visBounds, origin), red_ColorId);
+        return;
+    }
     enum iColorId      fg  = run->color;
     const iGmDocument *doc = d->widget->doc;
     const iBool        isHover =
@@ -1989,13 +1999,23 @@ static void drawRun_DrawContext_(void *context, const iGmRun *run) {
         /* Show metadata about inline content. */
         if (flags & content_GmLinkFlag && run->flags & endOfLine_GmRunFlag) {
             fg = linkColor_GmDocument(doc, run->linkId, textHover_GmLinkPart);
-            iAssert(!isEmpty_Rect(run->bounds));
-            iGmImageInfo info;
-            imageInfo_Media(constMedia_GmDocument(doc), linkImage_GmDocument(doc, run->linkId), &info);
             iString text;
             init_String(&text);
-            format_String(&text, "%s \u2014 %d x %d \u2014 %.1fMB",
-                          info.mime, info.size.x, info.size.y, info.numBytes / 1.0e6f);
+            iMediaId imageId = linkImage_GmDocument(doc, run->linkId);
+            iMediaId audioId = !imageId ? linkAudio_GmDocument(doc, run->linkId) : 0;
+            iAssert(imageId || audioId);
+            if (imageId) {
+                iAssert(!isEmpty_Rect(run->bounds));
+                iGmImageInfo info;
+                imageInfo_Media(constMedia_GmDocument(doc), imageId, &info);
+                format_String(&text, "%s \u2014 %d x %d \u2014 %.1fMB",
+                              info.mime, info.size.x, info.size.y, info.numBytes / 1.0e6f);
+            }
+            else if (audioId) {
+                iGmAudioInfo info;
+                audioInfo_Media(constMedia_GmDocument(doc), audioId, &info);
+                format_String(&text, "%s", info.mime);
+            }
             if (findMediaRequest_DocumentWidget_(d->widget, run->linkId)) {
                 appendFormat_String(
                     &text, "  %s\u2a2f", isHover ? escape_Color(tmLinkText_ColorId) : "");