Update alffplay for newer ffmpeg and convert to C++

1 files changed, 0 insertions, 1573 deletions

diff --git a/examples/alffplay.c b/examples/alffplay.c
deleted file mode 100644
index b61828f0..00000000
--- a/examples/alffplay.c
+++ /dev/null
@@ -1,1573 +0,0 @@
-/*
- * alffplay.c
- *
- * A pedagogical video player that really works! Now with seeking features.
- *
- * Code based on FFplay, Copyright (c) 2003 Fabrice Bellard, and a tutorial by
- * Martin Bohme <[email protected]>.
- *
- * Requires C99.
- */
-
-#include <stdio.h>
-#include <math.h>
-
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavformat/avio.h>
-#include <libavutil/time.h>
-#include <libavutil/avstring.h>
-#include <libavutil/channel_layout.h>
-#include <libswscale/swscale.h>
-#include <libswresample/swresample.h>
-
-#include <SDL.h>
-#include <SDL_thread.h>
-#include <SDL_video.h>
-
-#include "threads.h"
-#include "bool.h"
-
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "AL/alext.h"
-
-
-static bool has_direct_out = false;
-static bool has_latency_check = false;
-static LPALGETSOURCEDVSOFT alGetSourcedvSOFT;
-
-#define AUDIO_BUFFER_TIME 100 /* In milliseconds, per-buffer */
-#define AUDIO_BUFFER_QUEUE_SIZE 8 /* Number of buffers to queue */
-#define MAX_AUDIOQ_SIZE (5 * 16 * 1024) /* Bytes of compressed audio data to keep queued */
-#define MAX_VIDEOQ_SIZE (5 * 256 * 1024) /* Bytes of compressed video data to keep queued */
-#define AV_SYNC_THRESHOLD 0.01
-#define AV_NOSYNC_THRESHOLD 10.0
-#define SAMPLE_CORRECTION_MAX_DIFF 0.1
-#define AUDIO_DIFF_AVG_NB 20
-#define VIDEO_PICTURE_QUEUE_SIZE 16
-
-enum {
-    FF_UPDATE_EVENT = SDL_USEREVENT,
-    FF_REFRESH_EVENT,
-    FF_QUIT_EVENT
-};
-
-
-typedef struct PacketQueue {
-    AVPacketList *first_pkt, *last_pkt;
-    volatile int nb_packets;
-    volatile int size;
-    volatile bool flushing;
-    almtx_t mutex;
-    alcnd_t cond;
-} PacketQueue;
-
-typedef struct VideoPicture {
-    SDL_Texture *bmp;
-    int width, height; /* Logical image size (actual size may be larger) */
-    volatile bool updated;
-    double pts;
-} VideoPicture;
-
-typedef struct AudioState {
-    AVStream *st;
-
-    PacketQueue q;
-    AVPacket    pkt;
-
-    /* Used for clock difference average computation */
-    double diff_accum;
-    double diff_avg_coef;
-    double diff_threshold;
-
-    /* Time (in seconds) of the next sample to be buffered */
-    double current_pts;
-
-    /* Decompressed sample frame, and swresample context for conversion */
-    AVFrame           *decoded_aframe;
-    struct SwrContext *swres_ctx;
-
-    /* Conversion format, for what gets fed to OpenAL */
-    int                 dst_ch_layout;
-    enum AVSampleFormat dst_sample_fmt;
-
-    /* Storage of converted samples */
-    uint8_t *samples;
-    ssize_t samples_len; /* In samples */
-    ssize_t samples_pos;
-    int     samples_max;
-
-    /* OpenAL format */
-    ALenum  format;
-    ALint   frame_size;
-
-    ALuint  source;
-    ALuint  buffer[AUDIO_BUFFER_QUEUE_SIZE];
-    ALuint  buffer_idx;
-    almtx_t src_mutex;
-
-    althrd_t thread;
-} AudioState;
-
-typedef struct VideoState {
-    AVStream *st;
-
-    PacketQueue q;
-
-    double  clock;
-    double  frame_timer;
-    double  frame_last_pts;
-    double  frame_last_delay;
-    double  current_pts;
-    /* time (av_gettime) at which we updated current_pts - used to have running video pts */
-    int64_t current_pts_time;
-
-    /* Decompressed video frame, and swscale context for conversion */
-    AVFrame           *decoded_vframe;
-    struct SwsContext *swscale_ctx;
-
-    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
-    int          pictq_size, pictq_rindex, pictq_windex;
-    almtx_t      pictq_mutex;
-    alcnd_t      pictq_cond;
-
-    althrd_t thread;
-} VideoState;
-
-typedef struct MovieState {
-    AVFormatContext *pFormatCtx;
-    int             videoStream, audioStream;
-
-    volatile bool seek_req;
-    int64_t       seek_pos;
-    volatile bool direct_req;
-
-    int av_sync_type;
-
-    int64_t external_clock_base;
-
-    AudioState audio;
-    VideoState video;
-
-    althrd_t parse_thread;
-
-    char filename[1024];
-
-    volatile bool quit;
-} MovieState;
-
-enum {
-    AV_SYNC_AUDIO_MASTER,
-    AV_SYNC_VIDEO_MASTER,
-    AV_SYNC_EXTERNAL_MASTER,
-
-    DEFAULT_AV_SYNC_TYPE = AV_SYNC_EXTERNAL_MASTER
-};
-
-static AVPacket flush_pkt = { .data = (uint8_t*)"FLUSH" };
-
-static void packet_queue_init(PacketQueue *q)
-{
-    memset(q, 0, sizeof(PacketQueue));
-    almtx_init(&q->mutex, almtx_plain);
-    alcnd_init(&q->cond);
-}
-static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
-{
-    AVPacketList *pkt1;
-    if(pkt != &flush_pkt && !pkt->buf && av_dup_packet(pkt) < 0)
-        return -1;
-
-    pkt1 = av_malloc(sizeof(AVPacketList));
-    if(!pkt1) return -1;
-    pkt1->pkt = *pkt;
-    pkt1->next = NULL;
-
-    almtx_lock(&q->mutex);
-    if(!q->last_pkt)
-        q->first_pkt = pkt1;
-    else
-        q->last_pkt->next = pkt1;
-    q->last_pkt = pkt1;
-    q->nb_packets++;
-    q->size += pkt1->pkt.size;
-    almtx_unlock(&q->mutex);
-
-    alcnd_signal(&q->cond);
-    return 0;
-}
-static int packet_queue_get(PacketQueue *q, AVPacket *pkt, MovieState *state)
-{
-    AVPacketList *pkt1;
-    int ret = -1;
-
-    almtx_lock(&q->mutex);
-    while(!state->quit)
-    {
-        pkt1 = q->first_pkt;
-        if(pkt1)
-        {
-            q->first_pkt = pkt1->next;
-            if(!q->first_pkt)
-                q->last_pkt = NULL;
-            q->nb_packets--;
-            q->size -= pkt1->pkt.size;
-            *pkt = pkt1->pkt;
-            av_free(pkt1);
-            ret = 1;
-            break;
-        }
-
-        if(q->flushing)
-        {
-            ret = 0;
-            break;
-        }
-        alcnd_wait(&q->cond, &q->mutex);
-    }
-    almtx_unlock(&q->mutex);
-    return ret;
-}
-static void packet_queue_clear(PacketQueue *q)
-{
-    AVPacketList *pkt, *pkt1;
-
-    almtx_lock(&q->mutex);
-    for(pkt = q->first_pkt;pkt != NULL;pkt = pkt1)
-    {
-        pkt1 = pkt->next;
-        if(pkt->pkt.data != flush_pkt.data)
-            av_free_packet(&pkt->pkt);
-        av_freep(&pkt);
-    }
-    q->last_pkt = NULL;
-    q->first_pkt = NULL;
-    q->nb_packets = 0;
-    q->size = 0;
-    almtx_unlock(&q->mutex);
-}
-static void packet_queue_flush(PacketQueue *q)
-{
-    almtx_lock(&q->mutex);
-    q->flushing = true;
-    almtx_unlock(&q->mutex);
-    alcnd_signal(&q->cond);
-}
-static void packet_queue_deinit(PacketQueue *q)
-{
-    packet_queue_clear(q);
-    alcnd_destroy(&q->cond);
-    almtx_destroy(&q->mutex);
-}
-
-
-static double get_audio_clock(AudioState *state)
-{
-    double pts;
-
-    almtx_lock(&state->src_mutex);
-    /* The audio clock is the timestamp of the sample currently being heard.
-     * It's based on 4 components:
-     * 1 - The timestamp of the next sample to buffer (state->current_pts)
-     * 2 - The length of the source's buffer queue (AL_SEC_LENGTH_SOFT)
-     * 3 - The offset OpenAL is currently at in the source (the first value
-     *     from AL_SEC_OFFSET_LATENCY_SOFT)
-     * 4 - The latency between OpenAL and the DAC (the second value from
-     *     AL_SEC_OFFSET_LATENCY_SOFT)
-     *
-     * Subtracting the length of the source queue from the next sample's
-     * timestamp gives the timestamp of the sample at start of the source
-     * queue. Adding the source offset to that results in the timestamp for
-     * OpenAL's current position, and subtracting the source latency from that
-     * gives the timestamp of the sample currently at the DAC.
-     */
-    pts = state->current_pts;
-    if(state->source)
-    {
-        ALdouble offset[2] = { 0.0, 0.0 };
-        ALdouble queue_len = 0.0;
-        ALint status;
-
-        /* NOTE: The source state must be checked last, in case an underrun
-         * occurs and the source stops between retrieving the offset+latency
-         * and getting the state. */
-        if(has_latency_check)
-        {
-            alGetSourcedvSOFT(state->source, AL_SEC_OFFSET_LATENCY_SOFT, offset);
-            alGetSourcedvSOFT(state->source, AL_SEC_LENGTH_SOFT, &queue_len);
-        }
-        else
-        {
-            ALint ioffset, ilen;
-            alGetSourcei(state->source, AL_SAMPLE_OFFSET, &ioffset);
-            alGetSourcei(state->source, AL_SAMPLE_LENGTH_SOFT, &ilen);
-            offset[0] = (double)ioffset / state->st->codec->sample_rate;
-            queue_len = (double)ilen / state->st->codec->sample_rate;
-        }
-        alGetSourcei(state->source, AL_SOURCE_STATE, &status);
-
-        /* If the source is AL_STOPPED, then there was an underrun and all
-         * buffers are processed, so ignore the source queue. The audio thread
-         * will put the source into an AL_INITIAL state and clear the queue
-         * when it starts recovery. */
-        if(status != AL_STOPPED)
-            pts = pts - queue_len + offset[0];
-        if(status == AL_PLAYING)
-            pts = pts - offset[1];
-    }
-    almtx_unlock(&state->src_mutex);
-
-    return (pts >= 0.0) ? pts : 0.0;
-}
-static double get_video_clock(VideoState *state)
-{
-    double delta = (av_gettime() - state->current_pts_time) / 1000000.0;
-    return state->current_pts + delta;
-}
-static double get_external_clock(MovieState *movState)
-{
-    return (av_gettime()-movState->external_clock_base) / 1000000.0;
-}
-
-double get_master_clock(MovieState *movState)
-{
-    if(movState->av_sync_type == AV_SYNC_VIDEO_MASTER)
-        return get_video_clock(&movState->video);
-    if(movState->av_sync_type == AV_SYNC_AUDIO_MASTER)
-        return get_audio_clock(&movState->audio);
-    return get_external_clock(movState);
-}
-
-/* Return how many samples to skip to maintain sync (negative means to
- * duplicate samples). */
-static int synchronize_audio(MovieState *movState)
-{
-    double diff, avg_diff;
-    double ref_clock;
-
-    if(movState->av_sync_type == AV_SYNC_AUDIO_MASTER)
-        return 0;
-
-    ref_clock = get_master_clock(movState);
-    diff = ref_clock - get_audio_clock(&movState->audio);
-
-    if(!(fabs(diff) < AV_NOSYNC_THRESHOLD))
-    {
-        /* Difference is TOO big; reset diff stuff */
-        movState->audio.diff_accum = 0.0;
-        return 0;
-    }
-
-    /* Accumulate the diffs */
-    movState->audio.diff_accum = movState->audio.diff_accum*movState->audio.diff_avg_coef + diff;
-    avg_diff = movState->audio.diff_accum*(1.0 - movState->audio.diff_avg_coef);
-    if(fabs(avg_diff) < movState->audio.diff_threshold)
-        return 0;
-
-    /* Constrain the per-update difference to avoid exceedingly large skips */
-    if(!(diff <= SAMPLE_CORRECTION_MAX_DIFF))
-        diff = SAMPLE_CORRECTION_MAX_DIFF;
-    else if(!(diff >= -SAMPLE_CORRECTION_MAX_DIFF))
-        diff = -SAMPLE_CORRECTION_MAX_DIFF;
-    return (int)(diff*movState->audio.st->codec->sample_rate);
-}
-
-static int audio_decode_frame(MovieState *movState)
-{
-    AVPacket *pkt = &movState->audio.pkt;
-
-    while(!movState->quit)
-    {
-        while(!movState->quit && pkt->size == 0)
-        {
-            av_free_packet(pkt);
-
-            /* Get the next packet */
-            int err;
-            if((err=packet_queue_get(&movState->audio.q, pkt, movState)) <= 0)
-            {
-                if(err == 0)
-                    break;
-                return err;
-            }
-            if(pkt->data == flush_pkt.data)
-            {
-                avcodec_flush_buffers(movState->audio.st->codec);
-                movState->audio.diff_accum = 0.0;
-                movState->audio.current_pts = av_q2d(movState->audio.st->time_base)*pkt->pts;
-
-                alSourceRewind(movState->audio.source);
-                alSourcei(movState->audio.source, AL_BUFFER, 0);
-
-                av_new_packet(pkt, 0);
-
-                return -1;
-            }
-
-            /* If provided, update w/ pts */
-            if(pkt->pts != AV_NOPTS_VALUE)
-                movState->audio.current_pts = av_q2d(movState->audio.st->time_base)*pkt->pts;
-        }
-
-        AVFrame *frame = movState->audio.decoded_aframe;
-        int got_frame = 0;
-        int len1 = avcodec_decode_audio4(movState->audio.st->codec, frame,
-                                         &got_frame, pkt);
-        if(len1 < 0)
-        {
-            av_shrink_packet(pkt, 0);
-            continue;
-        }
-
-        if(len1 <= pkt->size)
-        {
-            /* Move the unread data to the front and clear the end bits */
-            int remaining = pkt->size - len1;
-            memmove(pkt->data, &pkt->data[len1], remaining);
-            av_shrink_packet(pkt, remaining);
-        }
-
-        if(!got_frame || frame->nb_samples <= 0)
-        {
-            av_frame_unref(frame);
-            continue;
-        }
-
-        if(frame->nb_samples > movState->audio.samples_max)
-        {
-            av_freep(&movState->audio.samples);
-            av_samples_alloc(
-                &movState->audio.samples, NULL, movState->audio.st->codec->channels,
-                frame->nb_samples, movState->audio.dst_sample_fmt, 0
-            );
-            movState->audio.samples_max = frame->nb_samples;
-        }
-        /* Return the amount of sample frames converted */
-        int data_size = swr_convert(movState->audio.swres_ctx,
-            &movState->audio.samples, frame->nb_samples,
-            (const uint8_t**)frame->data, frame->nb_samples
-        );
-
-        av_frame_unref(frame);
-        return data_size;
-    }
-
-    return -1;
-}
-
-static int read_audio(MovieState *movState, uint8_t *samples, int length)
-{
-    int sample_skip = synchronize_audio(movState);
-    int audio_size = 0;
-
-    /* Read the next chunk of data, refill the buffer, and queue it
-     * on the source */
-    length /= movState->audio.frame_size;
-    while(audio_size < length)
-    {
-        if(movState->audio.samples_len <= 0 || movState->audio.samples_pos >= movState->audio.samples_len)
-        {
-            int frame_len = audio_decode_frame(movState);
-            if(frame_len < 0) return -1;
-
-            movState->audio.samples_len = frame_len;
-            if(movState->audio.samples_len == 0)
-                break;
-
-            movState->audio.samples_pos = (movState->audio.samples_len < sample_skip) ?
-                                          movState->audio.samples_len : sample_skip;
-            sample_skip -= movState->audio.samples_pos;
-
-            movState->audio.current_pts += (double)movState->audio.samples_pos /
-                                           (double)movState->audio.st->codec->sample_rate;
-            continue;
-        }
-
-        int rem = length - audio_size;
-        if(movState->audio.samples_pos >= 0)
-        {
-            int n = movState->audio.frame_size;
-            int len = movState->audio.samples_len - movState->audio.samples_pos;
-            if(rem > len) rem = len;
-            memcpy(samples + audio_size*n,
-                   movState->audio.samples + movState->audio.samples_pos*n,
-                   rem*n);
-        }
-        else
-        {
-            int n = movState->audio.frame_size;
-            int len = -movState->audio.samples_pos;
-            if(rem > len) rem = len;
-
-            /* Add samples by copying the first sample */
-            if(n == 1)
-            {
-                uint8_t sample = ((uint8_t*)movState->audio.samples)[0];
-                uint8_t *q = (uint8_t*)samples + audio_size;
-                for(int i = 0;i < rem;i++)
-                    *(q++) = sample;
-            }
-            else if(n == 2)
-            {
-                uint16_t sample = ((uint16_t*)movState->audio.samples)[0];
-                uint16_t *q = (uint16_t*)samples + audio_size;
-                for(int i = 0;i < rem;i++)
-                    *(q++) = sample;
-            }
-            else if(n == 4)
-            {
-                uint32_t sample = ((uint32_t*)movState->audio.samples)[0];
-                uint32_t *q = (uint32_t*)samples + audio_size;
-                for(int i = 0;i < rem;i++)
-                    *(q++) = sample;
-            }
-            else if(n == 8)
-            {
-                uint64_t sample = ((uint64_t*)movState->audio.samples)[0];
-                uint64_t *q = (uint64_t*)samples + audio_size;
-                for(int i = 0;i < rem;i++)
-                    *(q++) = sample;
-            }
-            else
-            {
-                uint8_t *sample = movState->audio.samples;
-                uint8_t *q = samples + audio_size*n;
-                for(int i = 0;i < rem;i++)
-                {
-                    memcpy(q, sample, n);
-                    q += n;
-                }
-            }
-        }
-
-        movState->audio.samples_pos += rem;
-        movState->audio.current_pts += (double)rem / movState->audio.st->codec->sample_rate;
-        audio_size += rem;
-    }
-
-    return audio_size * movState->audio.frame_size;
-}
-
-static int audio_thread(void *userdata)
-{
-    MovieState *movState = (MovieState*)userdata;
-    uint8_t *samples = NULL;
-    ALsizei buffer_len;
-    ALenum fmt;
-
-    alGenBuffers(AUDIO_BUFFER_QUEUE_SIZE, movState->audio.buffer);
-    alGenSources(1, &movState->audio.source);
-
-    alSourcei(movState->audio.source, AL_SOURCE_RELATIVE, AL_TRUE);
-    alSourcei(movState->audio.source, AL_ROLLOFF_FACTOR, 0);
-
-    av_new_packet(&movState->audio.pkt, 0);
-
-    /* Find a suitable format for OpenAL. */
-    movState->audio.format = AL_NONE;
-    if(movState->audio.st->codec->sample_fmt == AV_SAMPLE_FMT_U8 ||
-       movState->audio.st->codec->sample_fmt == AV_SAMPLE_FMT_U8P)
-    {
-        movState->audio.dst_sample_fmt = AV_SAMPLE_FMT_U8;
-        movState->audio.frame_size = 1;
-        if(movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_7POINT1 &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_71CHN8")) != AL_NONE && fmt != -1)
-        {
-            movState->audio.dst_ch_layout = movState->audio.st->codec->channel_layout;
-            movState->audio.frame_size *= 8;
-            movState->audio.format = fmt;
-        }
-        if((movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_5POINT1 ||
-            movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_51CHN8")) != AL_NONE && fmt != -1)
-        {
-            movState->audio.dst_ch_layout = movState->audio.st->codec->channel_layout;
-            movState->audio.frame_size *= 6;
-            movState->audio.format = fmt;
-        }
-        if(movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_MONO)
-        {
-            movState->audio.dst_ch_layout = AV_CH_LAYOUT_MONO;
-            movState->audio.frame_size *= 1;
-            movState->audio.format = AL_FORMAT_MONO8;
-        }
-        if(movState->audio.format == AL_NONE)
-        {
-            movState->audio.dst_ch_layout = AV_CH_LAYOUT_STEREO;
-            movState->audio.frame_size *= 2;
-            movState->audio.format = AL_FORMAT_STEREO8;
-        }
-    }
-    if((movState->audio.st->codec->sample_fmt == AV_SAMPLE_FMT_FLT ||
-        movState->audio.st->codec->sample_fmt == AV_SAMPLE_FMT_FLTP) &&
-       alIsExtensionPresent("AL_EXT_FLOAT32"))
-    {
-        movState->audio.dst_sample_fmt = AV_SAMPLE_FMT_FLT;
-        movState->audio.frame_size = 4;
-        if(movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_7POINT1 &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_71CHN32")) != AL_NONE && fmt != -1)
-        {
-            movState->audio.dst_ch_layout = movState->audio.st->codec->channel_layout;
-            movState->audio.frame_size *= 8;
-            movState->audio.format = fmt;
-        }
-        if((movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_5POINT1 ||
-            movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_51CHN32")) != AL_NONE && fmt != -1)
-        {
-            movState->audio.dst_ch_layout = movState->audio.st->codec->channel_layout;
-            movState->audio.frame_size *= 6;
-            movState->audio.format = fmt;
-        }
-        if(movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_MONO)
-        {
-            movState->audio.dst_ch_layout = AV_CH_LAYOUT_MONO;
-            movState->audio.frame_size *= 1;
-            movState->audio.format = AL_FORMAT_MONO_FLOAT32;
-        }
-        if(movState->audio.format == AL_NONE)
-        {
-            movState->audio.dst_ch_layout = AV_CH_LAYOUT_STEREO;
-            movState->audio.frame_size *= 2;
-            movState->audio.format = AL_FORMAT_STEREO_FLOAT32;
-        }
-    }
-    if(movState->audio.format == AL_NONE)
-    {
-        movState->audio.dst_sample_fmt = AV_SAMPLE_FMT_S16;
-        movState->audio.frame_size = 2;
-        if(movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_7POINT1 &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_71CHN16")) != AL_NONE && fmt != -1)
-        {
-            movState->audio.dst_ch_layout = movState->audio.st->codec->channel_layout;
-            movState->audio.frame_size *= 8;
-            movState->audio.format = fmt;
-        }
-        if((movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_5POINT1 ||
-            movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) &&
-           alIsExtensionPresent("AL_EXT_MCFORMATS") &&
-           (fmt=alGetEnumValue("AL_FORMAT_51CHN16")) != AL_NONE && fmt != -1)
-        {
-            movState->audio.dst_ch_layout = movState->audio.st->codec->channel_layout;
-            movState->audio.frame_size *= 6;
-            movState->audio.format = fmt;
-        }
-        if(movState->audio.st->codec->channel_layout == AV_CH_LAYOUT_MONO)
-        {
-            movState->audio.dst_ch_layout = AV_CH_LAYOUT_MONO;
-            movState->audio.frame_size *= 1;
-            movState->audio.format = AL_FORMAT_MONO16;
-        }
-        if(movState->audio.format == AL_NONE)
-        {
-            movState->audio.dst_ch_layout = AV_CH_LAYOUT_STEREO;
-            movState->audio.frame_size *= 2;
-            movState->audio.format = AL_FORMAT_STEREO16;
-        }
-    }
-    buffer_len = AUDIO_BUFFER_TIME * movState->audio.st->codec->sample_rate / 1000 *
-                 movState->audio.frame_size;
-    samples = av_malloc(buffer_len);
-
-    movState->audio.samples = NULL;
-    movState->audio.samples_max = 0;
-    movState->audio.samples_pos = 0;
-    movState->audio.samples_len = 0;
-
-    if(!(movState->audio.decoded_aframe=av_frame_alloc()))
-    {
-        fprintf(stderr, "Failed to allocate audio frame\n");
-        goto finish;
-    }
-
-    movState->audio.swres_ctx = swr_alloc_set_opts(NULL,
-        movState->audio.dst_ch_layout,
-        movState->audio.dst_sample_fmt,
-        movState->audio.st->codec->sample_rate,
-        movState->audio.st->codec->channel_layout ?
-            movState->audio.st->codec->channel_layout :
-            (uint64_t)av_get_default_channel_layout(movState->audio.st->codec->channels),
-        movState->audio.st->codec->sample_fmt,
-        movState->audio.st->codec->sample_rate,
-        0, NULL
-    );
-    if(!movState->audio.swres_ctx || swr_init(movState->audio.swres_ctx) != 0)
-    {
-        fprintf(stderr, "Failed to initialize audio converter\n");
-        goto finish;
-    }
-
-    almtx_lock(&movState->audio.src_mutex);
-    while(alGetError() == AL_NO_ERROR && !movState->quit)
-    {
-        /* First remove any processed buffers. */
-        ALint processed;
-        alGetSourcei(movState->audio.source, AL_BUFFERS_PROCESSED, &processed);
-        alSourceUnqueueBuffers(movState->audio.source, processed, (ALuint[AUDIO_BUFFER_QUEUE_SIZE]){});
-
-        /* Refill the buffer queue. */
-        ALint queued;
-        alGetSourcei(movState->audio.source, AL_BUFFERS_QUEUED, &queued);
-        while(queued < AUDIO_BUFFER_QUEUE_SIZE)
-        {
-            int audio_size;
-
-            /* Read the next chunk of data, fill the buffer, and queue it on
-             * the source */
-            audio_size = read_audio(movState, samples, buffer_len);
-            if(audio_size < 0) break;
-
-            ALuint bufid = movState->audio.buffer[movState->audio.buffer_idx++];
-            movState->audio.buffer_idx %= AUDIO_BUFFER_QUEUE_SIZE;
-
-            alBufferData(bufid, movState->audio.format, samples, audio_size,
-                         movState->audio.st->codec->sample_rate);
-            alSourceQueueBuffers(movState->audio.source, 1, &bufid);
-            queued++;
-        }
-
-        /* Check that the source is playing. */
-        ALint state;
-        alGetSourcei(movState->audio.source, AL_SOURCE_STATE, &state);
-        if(state == AL_STOPPED)
-        {
-            /* AL_STOPPED means there was an underrun. Double-check that all
-             * processed buffers are removed, then rewind the source to get it
-             * back into an AL_INITIAL state. */
-            alGetSourcei(movState->audio.source, AL_BUFFERS_PROCESSED, &processed);
-            alSourceUnqueueBuffers(movState->audio.source, processed, (ALuint[AUDIO_BUFFER_QUEUE_SIZE]){});
-            alSourceRewind(movState->audio.source);
-            continue;
-        }
-
-        almtx_unlock(&movState->audio.src_mutex);
-
-        /* (re)start the source if needed, and wait for a buffer to finish */
-        if(state != AL_PLAYING && state != AL_PAUSED)
-        {
-            alGetSourcei(movState->audio.source, AL_BUFFERS_QUEUED, &queued);
-            if(queued > 0) alSourcePlay(movState->audio.source);
-        }
-        SDL_Delay(AUDIO_BUFFER_TIME);
-
-        if(movState->direct_req)
-        {
-            if(has_direct_out)
-            {
-                alGetSourcei(movState->audio.source, AL_DIRECT_CHANNELS_SOFT, &state);
-                state = !state;
-                alSourcei(movState->audio.source, AL_DIRECT_CHANNELS_SOFT,
-                          state ? AL_TRUE : AL_FALSE);
-                printf("Direct channels %s\n", state ? "on" : "off");
-                fflush(stdout);
-            }
-            movState->direct_req = false;
-        }
-
-        almtx_lock(&movState->audio.src_mutex);
-    }
-    almtx_unlock(&movState->audio.src_mutex);
-
-finish:
-    av_frame_free(&movState->audio.decoded_aframe);
-    swr_free(&movState->audio.swres_ctx);
-
-    av_freep(&samples);
-    av_freep(&movState->audio.samples);
-
-    alDeleteSources(1, &movState->audio.source);
-    alDeleteBuffers(AUDIO_BUFFER_QUEUE_SIZE, movState->audio.buffer);
-
-    return 0;
-}
-
-
-static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque)
-{
-    (void)interval;
-
-    SDL_PushEvent(&(SDL_Event){ .user={.type=FF_REFRESH_EVENT, .data1=opaque} });
-    return 0; /* 0 means stop timer */
-}
-
-/* Schedule a video refresh in 'delay' ms */
-static void schedule_refresh(MovieState *movState, int delay)
-{
-    SDL_AddTimer(delay, sdl_refresh_timer_cb, movState);
-}
-
-static void video_display(MovieState *movState, SDL_Window *screen, SDL_Renderer *renderer)
-{
-    VideoPicture *vp = &movState->video.pictq[movState->video.pictq_rindex];
-
-    if(!vp->bmp)
-        return;
-
-    float aspect_ratio;
-    int win_w, win_h;
-    int w, h, x, y;
-
-    if(movState->video.st->codec->sample_aspect_ratio.num == 0)
-        aspect_ratio = 0.0f;
-    else
-    {
-        aspect_ratio = av_q2d(movState->video.st->codec->sample_aspect_ratio) *
-                       movState->video.st->codec->width /
-                       movState->video.st->codec->height;
-    }
-    if(aspect_ratio <= 0.0f)
-    {
-        aspect_ratio = (float)movState->video.st->codec->width /
-                       (float)movState->video.st->codec->height;
-    }
-
-    SDL_GetWindowSize(screen, &win_w, &win_h);
-    h = win_h;
-    w = ((int)rint(h * aspect_ratio) + 3) & ~3;
-    if(w > win_w)
-    {
-        w = win_w;
-        h = ((int)rint(w / aspect_ratio) + 3) & ~3;
-    }
-    x = (win_w - w) / 2;
-    y = (win_h - h) / 2;
-
-    SDL_RenderCopy(renderer, vp->bmp,
-        &(SDL_Rect){ .x=0, .y=0, .w=vp->width, .h=vp->height },
-        &(SDL_Rect){ .x=x, .y=y, .w=w, .h=h }
-    );
-    SDL_RenderPresent(renderer);
-}
-
-static void video_refresh_timer(MovieState *movState, SDL_Window *screen, SDL_Renderer *renderer)
-{
-    if(!movState->video.st)
-    {
-        schedule_refresh(movState, 100);
-        return;
-    }
-
-    almtx_lock(&movState->video.pictq_mutex);
-retry:
-    if(movState->video.pictq_size == 0)
-        schedule_refresh(movState, 1);
-    else
-    {
-        VideoPicture *vp = &movState->video.pictq[movState->video.pictq_rindex];
-        double actual_delay, delay, sync_threshold, ref_clock, diff;
-
-        movState->video.current_pts = vp->pts;
-        movState->video.current_pts_time = av_gettime();
-
-        delay = vp->pts - movState->video.frame_last_pts; /* the pts from last time */
-        if(delay <= 0 || delay >= 1.0)
-        {
-            /* if incorrect delay, use previous one */
-            delay = movState->video.frame_last_delay;
-        }
-        /* save for next time */
-        movState->video.frame_last_delay = delay;
-        movState->video.frame_last_pts = vp->pts;
-
-        /* Update delay to sync to clock if not master source. */
-        if(movState->av_sync_type != AV_SYNC_VIDEO_MASTER)
-        {
-            ref_clock = get_master_clock(movState);
-            diff = vp->pts - ref_clock;
-
-            /* Skip or repeat the frame. Take delay into account. */
-            sync_threshold = (delay > AV_SYNC_THRESHOLD) ? delay : AV_SYNC_THRESHOLD;
-            if(fabs(diff) < AV_NOSYNC_THRESHOLD)
-            {
-                if(diff <= -sync_threshold)
-                    delay = 0;
-                else if(diff >= sync_threshold)
-                    delay = 2 * delay;
-            }
-        }
-
-        movState->video.frame_timer += delay;
-        /* Compute the REAL delay. */
-        actual_delay = movState->video.frame_timer - (av_gettime() / 1000000.0);
-        if(!(actual_delay >= 0.010))
-        {
-            /* We don't have time to handle this picture, just skip to the next one. */
-            movState->video.pictq_rindex = (movState->video.pictq_rindex+1)%VIDEO_PICTURE_QUEUE_SIZE;
-            movState->video.pictq_size--;
-            alcnd_signal(&movState->video.pictq_cond);
-            goto retry;
-        }
-        schedule_refresh(movState, (int)(actual_delay*1000.0 + 0.5));
-
-        /* Show the picture! */
-        video_display(movState, screen, renderer);
-
-        /* Update queue for next picture. */
-        movState->video.pictq_rindex = (movState->video.pictq_rindex+1)%VIDEO_PICTURE_QUEUE_SIZE;
-        movState->video.pictq_size--;
-        alcnd_signal(&movState->video.pictq_cond);
-    }
-    almtx_unlock(&movState->video.pictq_mutex);
-}
-
-
-static void update_picture(MovieState *movState, bool *first_update, SDL_Window *screen, SDL_Renderer *renderer)
-{
-    VideoPicture *vp = &movState->video.pictq[movState->video.pictq_windex];
-
-    /* allocate or resize the buffer! */
-    if(!vp->bmp || vp->width != movState->video.st->codec->width ||
-                   vp->height != movState->video.st->codec->height)
-    {
-        if(vp->bmp)
-            SDL_DestroyTexture(vp->bmp);
-        vp->bmp = SDL_CreateTexture(
-            renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
-            movState->video.st->codec->coded_width, movState->video.st->codec->coded_height
-        );
-        if(!vp->bmp)
-            fprintf(stderr, "Failed to create YV12 texture!\n");
-        vp->width = movState->video.st->codec->width;
-        vp->height = movState->video.st->codec->height;
-
-        if(*first_update && vp->width > 0 && vp->height > 0)
-        {
-            /* For the first update, set the window size to the video size. */
-            *first_update = false;
-
-            int w = vp->width;
-            int h = vp->height;
-            if(movState->video.st->codec->sample_aspect_ratio.num != 0 &&
-               movState->video.st->codec->sample_aspect_ratio.den != 0)
-            {
-                double aspect_ratio = av_q2d(movState->video.st->codec->sample_aspect_ratio);
-                if(aspect_ratio >= 1.0)
-                    w = (int)(w*aspect_ratio + 0.5);
-                else if(aspect_ratio > 0.0)
-                    h = (int)(h/aspect_ratio + 0.5);
-            }
-            SDL_SetWindowSize(screen, w, h);
-        }
-    }
-
-    if(vp->bmp)
-    {
-        AVFrame *frame = movState->video.decoded_vframe;
-        void *pixels = NULL;
-        int pitch = 0;
-
-        if(movState->video.st->codec->pix_fmt == AV_PIX_FMT_YUV420P)
-            SDL_UpdateYUVTexture(vp->bmp, NULL,
-                frame->data[0], frame->linesize[0],
-                frame->data[1], frame->linesize[1],
-                frame->data[2], frame->linesize[2]
-            );
-        else if(SDL_LockTexture(vp->bmp, NULL, &pixels, &pitch) != 0)
-            fprintf(stderr, "Failed to lock texture\n");
-        else
-        {
-            // Convert the image into YUV format that SDL uses
-            int coded_w = movState->video.st->codec->coded_width;
-            int coded_h = movState->video.st->codec->coded_height;
-            int w = movState->video.st->codec->width;
-            int h = movState->video.st->codec->height;
-            if(!movState->video.swscale_ctx)
-                movState->video.swscale_ctx = sws_getContext(
-                    w, h, movState->video.st->codec->pix_fmt,
-                    w, h, AV_PIX_FMT_YUV420P, SWS_X, NULL, NULL, NULL
-                );
-
-            /* point pict at the queue */
-            AVPicture pict;
-            pict.data[0] = pixels;
-            pict.data[2] = pict.data[0] + coded_w*coded_h;
-            pict.data[1] = pict.data[2] + coded_w*coded_h/4;
-
-            pict.linesize[0] = pitch;
-            pict.linesize[2] = pitch / 2;
-            pict.linesize[1] = pitch / 2;
-
-            sws_scale(movState->video.swscale_ctx, (const uint8_t**)frame->data,
-                      frame->linesize, 0, h, pict.data, pict.linesize);
-            SDL_UnlockTexture(vp->bmp);
-        }
-    }
-
-    almtx_lock(&movState->video.pictq_mutex);
-    vp->updated = true;
-    almtx_unlock(&movState->video.pictq_mutex);
-    alcnd_signal(&movState->video.pictq_cond);
-}
-
-static int queue_picture(MovieState *movState, double pts)
-{
-    /* Wait until we have space for a new pic */
-    almtx_lock(&movState->video.pictq_mutex);
-    while(movState->video.pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !movState->quit)
-        alcnd_wait(&movState->video.pictq_cond, &movState->video.pictq_mutex);
-    almtx_unlock(&movState->video.pictq_mutex);
-
-    if(movState->quit)
-        return -1;
-
-    VideoPicture *vp = &movState->video.pictq[movState->video.pictq_windex];
-
-    /* We have to create/update the picture in the main thread  */
-    vp->updated = false;
-    SDL_PushEvent(&(SDL_Event){ .user={.type=FF_UPDATE_EVENT, .data1=movState} });
-
-    /* Wait until the picture is updated. */
-    almtx_lock(&movState->video.pictq_mutex);
-    while(!vp->updated && !movState->quit)
-        alcnd_wait(&movState->video.pictq_cond, &movState->video.pictq_mutex);
-    almtx_unlock(&movState->video.pictq_mutex);
-    if(movState->quit)
-        return -1;
-    vp->pts = pts;
-
-    movState->video.pictq_windex = (movState->video.pictq_windex+1)%VIDEO_PICTURE_QUEUE_SIZE;
-    almtx_lock(&movState->video.pictq_mutex);
-    movState->video.pictq_size++;
-    almtx_unlock(&movState->video.pictq_mutex);
-
-    return 0;
-}
-
-static double synchronize_video(MovieState *movState, double pts)
-{
-    double frame_delay;
-
-    if(pts == 0.0) /* if we aren't given a pts, set it to the clock */
-        pts = movState->video.clock;
-    else /* if we have pts, set video clock to it */
-        movState->video.clock = pts;
-
-    /* update the video clock */
-    frame_delay = av_q2d(movState->video.st->codec->time_base);
-    /* if we are repeating a frame, adjust clock accordingly */
-    frame_delay += movState->video.decoded_vframe->repeat_pict * (frame_delay * 0.5);
-    movState->video.clock += frame_delay;
-    return pts;
-}
-
-int video_thread(void *arg)
-{
-    MovieState *movState = (MovieState*)arg;
-    AVPacket *packet = (AVPacket[1]){};
-    int64_t saved_pts, pkt_pts;
-    int frameFinished;
-
-    movState->video.decoded_vframe = av_frame_alloc();
-    while(packet_queue_get(&movState->video.q, packet, movState) >= 0)
-    {
-        if(packet->data == flush_pkt.data)
-        {
-            avcodec_flush_buffers(movState->video.st->codec);
-
-            almtx_lock(&movState->video.pictq_mutex);
-            movState->video.pictq_size = 0;
-            movState->video.pictq_rindex = 0;
-            movState->video.pictq_windex = 0;
-            almtx_unlock(&movState->video.pictq_mutex);
-
-            movState->video.clock = av_q2d(movState->video.st->time_base)*packet->pts;
-            movState->video.current_pts = movState->video.clock;
-            movState->video.current_pts_time = av_gettime();
-            continue;
-        }
-
-        pkt_pts = packet->pts;
-
-        /* Decode video frame */
-        avcodec_decode_video2(movState->video.st->codec, movState->video.decoded_vframe,
-                              &frameFinished, packet);
-        if(pkt_pts != AV_NOPTS_VALUE && !movState->video.decoded_vframe->opaque)
-        {
-            /* Store the packet's original pts in the frame, in case the frame
-             * is not finished decoding yet. */
-            saved_pts = pkt_pts;
-            movState->video.decoded_vframe->opaque = &saved_pts;
-        }
-
-        av_free_packet(packet);
-
-        if(frameFinished)
-        {
-            double pts = av_q2d(movState->video.st->time_base);
-            if(packet->dts != AV_NOPTS_VALUE)
-                pts *= packet->dts;
-            else if(movState->video.decoded_vframe->opaque)
-                pts *= *(int64_t*)movState->video.decoded_vframe->opaque;
-            else
-                pts *= 0.0;
-            movState->video.decoded_vframe->opaque = NULL;
-
-            pts = synchronize_video(movState, pts);
-            if(queue_picture(movState, pts) < 0)
-                break;
-        }
-    }
-
-    sws_freeContext(movState->video.swscale_ctx);
-    movState->video.swscale_ctx = NULL;
-    av_frame_free(&movState->video.decoded_vframe);
-    return 0;
-}
-
-
-static int stream_component_open(MovieState *movState, int stream_index)
-{
-    AVFormatContext *pFormatCtx = movState->pFormatCtx;
-    AVCodecContext *codecCtx;
-    AVCodec *codec;
-
-    if(stream_index < 0 || (unsigned int)stream_index >= pFormatCtx->nb_streams)
-        return -1;
-
-    /* Get a pointer to the codec context for the video stream, and open the
-     * associated codec */
-    codecCtx = pFormatCtx->streams[stream_index]->codec;
-
-    codec = avcodec_find_decoder(codecCtx->codec_id);
-    if(!codec || avcodec_open2(codecCtx, codec, NULL) < 0)
-    {
-        fprintf(stderr, "Unsupported codec!\n");
-        return -1;
-    }
-
-    /* Initialize and start the media type handler */
-    switch(codecCtx->codec_type)
-    {
-        case AVMEDIA_TYPE_AUDIO:
-            movState->audioStream = stream_index;
-            movState->audio.st = pFormatCtx->streams[stream_index];
-
-            /* Averaging filter for audio sync */
-            movState->audio.diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
-            /* Correct audio only if larger error than this */
-            movState->audio.diff_threshold = 2.0 * 0.050/* 50 ms */;
-
-            memset(&movState->audio.pkt, 0, sizeof(movState->audio.pkt));
-            if(althrd_create(&movState->audio.thread, audio_thread, movState) != althrd_success)
-            {
-                movState->audioStream = -1;
-                movState->audio.st = NULL;
-            }
-            break;
-
-        case AVMEDIA_TYPE_VIDEO:
-            movState->videoStream = stream_index;
-            movState->video.st = pFormatCtx->streams[stream_index];
-
-            movState->video.current_pts_time = av_gettime();
-            movState->video.frame_timer = (double)movState->video.current_pts_time /
-                                          1000000.0;
-            movState->video.frame_last_delay = 40e-3;
-
-            if(althrd_create(&movState->video.thread, video_thread, movState) != althrd_success)
-            {
-                movState->videoStream = -1;
-                movState->video.st = NULL;
-            }
-            break;
-
-        default:
-            break;
-    }
-
-    return 0;
-}
-
-static int decode_interrupt_cb(void *ctx)
-{
-    return ((MovieState*)ctx)->quit;
-}
-
-int decode_thread(void *arg)
-{
-    MovieState *movState = (MovieState *)arg;
-    AVFormatContext *fmtCtx = movState->pFormatCtx;
-    AVPacket *packet = (AVPacket[1]){};
-    int video_index = -1;
-    int audio_index = -1;
-
-    movState->videoStream = -1;
-    movState->audioStream = -1;
-
-    /* Dump information about file onto standard error */
-    av_dump_format(fmtCtx, 0, movState->filename, 0);
-
-    /* Find the first video and audio streams */
-    for(unsigned int i = 0;i < fmtCtx->nb_streams;i++)
-    {
-        if(fmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO && video_index < 0)
-            video_index = i;
-        else if(fmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO && audio_index < 0)
-            audio_index = i;
-    }
-    movState->external_clock_base = av_gettime();
-    if(audio_index >= 0)
-        stream_component_open(movState, audio_index);
-    if(video_index >= 0)
-        stream_component_open(movState, video_index);
-
-    if(movState->videoStream < 0 && movState->audioStream < 0)
-    {
-        fprintf(stderr, "%s: could not open codecs\n", movState->filename);
-        goto fail;
-    }
-
-    /* Main packet handling loop */
-    while(!movState->quit)
-    {
-        if(movState->seek_req)
-        {
-            int64_t seek_target = movState->seek_pos;
-            int stream_index= -1;
-
-            /* Prefer seeking on the video stream. */
-            if(movState->videoStream >= 0)
-                stream_index = movState->videoStream;
-            else if(movState->audioStream >= 0)
-                stream_index = movState->audioStream;
-
-            /* Get a seek timestamp for the appropriate stream. */
-            int64_t timestamp = seek_target;
-            if(stream_index >= 0)
-                timestamp = av_rescale_q(seek_target, AV_TIME_BASE_Q, fmtCtx->streams[stream_index]->time_base);
-
-            if(av_seek_frame(movState->pFormatCtx, stream_index, timestamp, 0) < 0)
-                fprintf(stderr, "%s: error while seeking\n", movState->pFormatCtx->filename);
-            else
-            {
-                /* Seek successful, clear the packet queues and send a special
-                 * 'flush' packet with the new stream clock time. */
-                if(movState->audioStream >= 0)
-                {
-                    packet_queue_clear(&movState->audio.q);
-                    flush_pkt.pts = av_rescale_q(seek_target, AV_TIME_BASE_Q,
-                        fmtCtx->streams[movState->audioStream]->time_base
-                    );
-                    packet_queue_put(&movState->audio.q, &flush_pkt);
-                }
-                if(movState->videoStream >= 0)
-                {
-                    packet_queue_clear(&movState->video.q);
-                    flush_pkt.pts = av_rescale_q(seek_target, AV_TIME_BASE_Q,
-                        fmtCtx->streams[movState->videoStream]->time_base
-                    );
-                    packet_queue_put(&movState->video.q, &flush_pkt);
-                }
-                movState->external_clock_base = av_gettime() - seek_target;
-            }
-            movState->seek_req = false;
-        }
-
-        if(movState->audio.q.size >= MAX_AUDIOQ_SIZE ||
-           movState->video.q.size >= MAX_VIDEOQ_SIZE)
-        {
-            SDL_Delay(10);
-            continue;
-        }
-
-        if(av_read_frame(movState->pFormatCtx, packet) < 0)
-        {
-            packet_queue_flush(&movState->video.q);
-            packet_queue_flush(&movState->audio.q);
-            break;
-        }
-
-        /* Place the packet in the queue it's meant for, or discard it. */
-        if(packet->stream_index == movState->videoStream)
-            packet_queue_put(&movState->video.q, packet);
-        else if(packet->stream_index == movState->audioStream)
-            packet_queue_put(&movState->audio.q, packet);
-        else
-            av_free_packet(packet);
-    }
-
-    /* all done - wait for it */
-    while(!movState->quit)
-    {
-        if(movState->audio.q.nb_packets == 0 && movState->video.q.nb_packets == 0)
-            break;
-        SDL_Delay(100);
-    }
-
-fail:
-    movState->quit = true;
-    packet_queue_flush(&movState->video.q);
-    packet_queue_flush(&movState->audio.q);
-
-    if(movState->videoStream >= 0)
-        althrd_join(movState->video.thread, NULL);
-    if(movState->audioStream >= 0)
-        althrd_join(movState->audio.thread, NULL);
-
-    SDL_PushEvent(&(SDL_Event){ .user={.type=FF_QUIT_EVENT, .data1=movState} });
-
-    return 0;
-}
-
-
-static void stream_seek(MovieState *movState, double incr)
-{
-    if(!movState->seek_req)
-    {
-        double newtime = get_master_clock(movState)+incr;
-        if(newtime <= 0.0) movState->seek_pos = 0;
-        else movState->seek_pos = (int64_t)(newtime * AV_TIME_BASE);
-        movState->seek_req = true;
-    }
-}
-
-int main(int argc, char *argv[])
-{
-    SDL_Event event;
-    MovieState *movState;
-    bool first_update = true;
-    SDL_Window   *screen;
-    SDL_Renderer *renderer;
-    ALCdevice  *device;
-    ALCcontext *context;
-    int fileidx;
-
-    if(argc < 2)
-    {
-        fprintf(stderr, "Usage: %s <file>\n", argv[0]);
-        return 1;
-    }
-    /* Register all formats and codecs */
-    av_register_all();
-    /* Initialize networking protocols */
-    avformat_network_init();
-
-    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER))
-    {
-        fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
-        return 1;
-    }
-
-    /* Make a window to put our video */
-    screen = SDL_CreateWindow("alffplay", 0, 0, 640, 480, SDL_WINDOW_RESIZABLE);
-    if(!screen)
-    {
-        fprintf(stderr, "SDL: could not set video mode - exiting\n");
-        return 1;
-    }
-    /* Make a renderer to handle the texture image surface and rendering. */
-    renderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_ACCELERATED);
-    if(renderer)
-    {
-        SDL_RendererInfo rinf;
-        bool ok = false;
-
-        /* Make sure the renderer supports YV12 textures. If not, fallback to a
-         * software renderer. */
-        if(SDL_GetRendererInfo(renderer, &rinf) == 0)
-        {
-            for(Uint32 i = 0;!ok && i < rinf.num_texture_formats;i++)
-                ok = (rinf.texture_formats[i] == SDL_PIXELFORMAT_YV12);
-        }
-        if(!ok)
-        {
-            fprintf(stderr, "YV12 pixelformat textures not supported on renderer %s\n", rinf.name);
-            SDL_DestroyRenderer(renderer);
-            renderer = NULL;
-        }
-    }
-    if(!renderer)
-        renderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_SOFTWARE);
-    if(!renderer)
-    {
-        fprintf(stderr, "SDL: could not create renderer - exiting\n");
-        return 1;
-    }
-    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
-    SDL_RenderFillRect(renderer, NULL);
-    SDL_RenderPresent(renderer);
-
-    /* Open an audio device */
-    fileidx = 1;
-    device = NULL;
-    if(argc > 3 && strcmp(argv[1], "-device") == 0)
-    {
-        fileidx = 3;
-        device = alcOpenDevice(argv[2]);
-        if(!device)
-            fprintf(stderr, "OpenAL: could not open \"%s\" - trying default\n", argv[2]);
-    }
-    if(!device)
-        device = alcOpenDevice(NULL);
-    if(!device)
-    {
-        fprintf(stderr, "OpenAL: could not open device - exiting\n");
-        return 1;
-    }
-    context = alcCreateContext(device, NULL);
-    if(!context)
-    {
-        fprintf(stderr, "OpenAL: could not create context - exiting\n");
-        return 1;
-    }
-    if(alcMakeContextCurrent(context) == ALC_FALSE)
-    {
-        fprintf(stderr, "OpenAL: could not make context current - exiting\n");
-        return 1;
-    }
-
-    if(!alIsExtensionPresent("AL_SOFT_source_length"))
-    {
-        fprintf(stderr, "Required AL_SOFT_source_length not supported - exiting\n");
-        return 1;
-    }
-
-    if(!alIsExtensionPresent("AL_SOFT_direct_channels"))
-        fprintf(stderr, "AL_SOFT_direct_channels not supported.\n");
-    else
-        has_direct_out = true;
-
-    if(!alIsExtensionPresent("AL_SOFT_source_latency"))
-        fprintf(stderr, "AL_SOFT_source_latency not supported, audio may be a bit laggy.\n");
-    else
-    {
-        alGetSourcedvSOFT = alGetProcAddress("alGetSourcedvSOFT");
-        has_latency_check = true;
-    }
-
-
-    movState = av_mallocz(sizeof(MovieState));
-
-    av_strlcpy(movState->filename, argv[fileidx], sizeof(movState->filename));
-
-    packet_queue_init(&movState->audio.q);
-    packet_queue_init(&movState->video.q);
-
-    almtx_init(&movState->video.pictq_mutex, almtx_plain);
-    alcnd_init(&movState->video.pictq_cond);
-    almtx_init(&movState->audio.src_mutex, almtx_recursive);
-
-    movState->av_sync_type = DEFAULT_AV_SYNC_TYPE;
-
-    movState->pFormatCtx = avformat_alloc_context();
-    movState->pFormatCtx->interrupt_callback = (AVIOInterruptCB){.callback=decode_interrupt_cb, .opaque=movState};
-
-    if(avio_open2(&movState->pFormatCtx->pb, movState->filename, AVIO_FLAG_READ,
-                  &movState->pFormatCtx->interrupt_callback, NULL))
-    {
-        fprintf(stderr, "Failed to open %s\n", movState->filename);
-        return 1;
-    }
-
-    /* Open movie file */
-    if(avformat_open_input(&movState->pFormatCtx, movState->filename, NULL, NULL) != 0)
-    {
-        fprintf(stderr, "Failed to open %s\n", movState->filename);
-        return 1;
-    }
-
-    /* Retrieve stream information */
-    if(avformat_find_stream_info(movState->pFormatCtx, NULL) < 0)
-    {
-        fprintf(stderr, "%s: failed to find stream info\n", movState->filename);
-        return 1;
-    }
-
-    schedule_refresh(movState, 40);
-
-
-    if(althrd_create(&movState->parse_thread, decode_thread, movState) != althrd_success)
-    {
-        fprintf(stderr, "Failed to create parse thread!\n");
-        return 1;
-    }
-    while(SDL_WaitEvent(&event) == 1)
-    {
-        switch(event.type)
-        {
-            case SDL_KEYDOWN:
-                switch(event.key.keysym.sym)
-                {
-                    case SDLK_ESCAPE:
-                        movState->quit = true;
-                        break;
-
-                    case SDLK_LEFT:
-                        stream_seek(movState, -10.0);
-                        break;
-                    case SDLK_RIGHT:
-                        stream_seek(movState, 10.0);
-                        break;
-                    case SDLK_UP:
-                        stream_seek(movState, 30.0);
-                        break;
-                    case SDLK_DOWN:
-                        stream_seek(movState, -30.0);
-                        break;
-
-                    case SDLK_d:
-                        movState->direct_req = true;
-                        break;
-
-                    default:
-                        break;
-                }
-                break;
-
-            case SDL_WINDOWEVENT:
-                switch(event.window.event)
-                {
-                    case SDL_WINDOWEVENT_RESIZED:
-                        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
-                        SDL_RenderFillRect(renderer, NULL);
-                        break;
-
-                    default:
-                        break;
-                }
-                break;
-
-            case SDL_QUIT:
-                movState->quit = true;
-                break;
-
-            case FF_UPDATE_EVENT:
-                update_picture(event.user.data1, &first_update, screen, renderer);
-                break;
-
-            case FF_REFRESH_EVENT:
-                video_refresh_timer(event.user.data1, screen, renderer);
-                break;
-
-            case FF_QUIT_EVENT:
-                althrd_join(movState->parse_thread, NULL);
-
-                avformat_close_input(&movState->pFormatCtx);
-
-                almtx_destroy(&movState->audio.src_mutex);
-                almtx_destroy(&movState->video.pictq_mutex);
-                alcnd_destroy(&movState->video.pictq_cond);
-                packet_queue_deinit(&movState->video.q);
-                packet_queue_deinit(&movState->audio.q);
-
-                alcMakeContextCurrent(NULL);
-                alcDestroyContext(context);
-                alcCloseDevice(device);
-
-                SDL_Quit();
-                exit(0);
-
-            default:
-                break;
-        }
-    }
-
-    fprintf(stderr, "SDL_WaitEvent error - %s\n", SDL_GetError());
-    return 1;
-}