third_party/libdav1d/examples/dav1dplay.c - cobalt - Git at Google

 /*
  * Copyright © 2019, VideoLAN and dav1d authors
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright notice, this
  *    list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "vcs_version.h"

 #include <getopt.h>
 #include <stdbool.h>

 #include <SDL.h>

 #include "dav1d/dav1d.h"

 #include "common/attributes.h"
 #include "tools/input/input.h"
 #include "dp_fifo.h"
 #include "dp_renderer.h"

 #define FRAME_OFFSET_TO_PTS(foff) \
     (uint64_t)(((foff) * rd_ctx->spf) * 1000000000.0 + .5)
 #define TS_TO_PTS(ts) \
     (uint64_t)(((ts) * rd_ctx->timebase) * 1000000000.0 + .5)

 // Selected renderer callbacks and cookie
 static const Dav1dPlayRenderInfo *renderer_info = { NULL };

 /**
  * Render context structure
  * This structure contains informations necessary
  * to be shared between the decoder and the renderer
  * threads.
  */
 typedef struct render_context
 {
     Dav1dPlaySettings settings;
     Dav1dSettings lib_settings;

     // Renderer private data (passed to callbacks)
     void *rd_priv;

     // Lock to protect access to the context structure
     SDL_mutex *lock;

     // Timestamp of last displayed frame (in timebase unit)
     int64_t last_ts;
     // Timestamp of last decoded frame (in timebase unit)
     int64_t current_ts;
     // Ticks when last frame was received
     uint32_t last_ticks;
     // PTS time base
     double timebase;
     // Seconds per frame
     double spf;
     // Number of frames
     uint32_t total;

     // Fifo
     Dav1dPlayPtrFifo *fifo;

     // Custom SDL2 event types
     uint32_t event_types;

     // User pause state
     uint8_t user_paused;
     // Internal pause state
     uint8_t paused;
     // Start of internal pause state
     uint32_t pause_start;
     // Duration of internal pause state
     uint32_t pause_time;

     // Seek accumulator
     int seek;

     // Indicates if termination of the decoder thread was requested
     uint8_t dec_should_terminate;
 } Dav1dPlayRenderContext;

 static void dp_settings_print_usage(const char *const app,
                                     const char *const reason, ...)
 {
     if (reason) {
         va_list args;

         va_start(args, reason);
         vfprintf(stderr, reason, args);
         va_end(args);
         fprintf(stderr, "\n\n");
     }
     fprintf(stderr, "Usage: %s [options]\n\n", app);
     fprintf(stderr, "Supported options:\n"
             " --input/-i  $file:    input file\n"
             " --untimed/-u:         ignore PTS, render as fast as possible\n"
             " --threads $num:       number of threads (default: 0)\n"
             " --framedelay $num:    maximum frame delay, capped at $threads (default: 0);\n"
             "                       set to 1 for low-latency decoding\n"
             " --highquality:        enable high quality rendering\n"
             " --zerocopy/-z:        enable zero copy upload path\n"
             " --gpugrain/-g:        enable GPU grain synthesis\n"
             " --version/-v:         print version and exit\n"
             " --renderer/-r:        select renderer backend (default: auto)\n");
     exit(1);
 }

 static unsigned parse_unsigned(const char *const optarg, const int option,
                                const char *const app)
 {
     char *end;
     const unsigned res = (unsigned) strtoul(optarg, &end, 0);
     if (*end || end == optarg)
         dp_settings_print_usage(app, "Invalid argument \"%s\" for option %s; should be an integer",
           optarg, option);
     return res;
 }

 static void dp_rd_ctx_parse_args(Dav1dPlayRenderContext *rd_ctx,
                                  const int argc, char *const *const argv)
 {
     int o;
     Dav1dPlaySettings *settings = &rd_ctx->settings;
     Dav1dSettings *lib_settings = &rd_ctx->lib_settings;

     // Short options
     static const char short_opts[] = "i:vuzgr:";

     enum {
         ARG_THREADS = 256,
         ARG_FRAME_DELAY,
         ARG_HIGH_QUALITY,
     };

     // Long options
     static const struct option long_opts[] = {
         { "input",          1, NULL, 'i' },
         { "version",        0, NULL, 'v' },
         { "untimed",        0, NULL, 'u' },
         { "threads",        1, NULL, ARG_THREADS },
         { "framedelay",     1, NULL, ARG_FRAME_DELAY },
         { "highquality",    0, NULL, ARG_HIGH_QUALITY },
         { "zerocopy",       0, NULL, 'z' },
         { "gpugrain",       0, NULL, 'g' },
         { "renderer",       0, NULL, 'r'},
         { NULL,             0, NULL, 0 },
     };

     while ((o = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
         switch (o) {
             case 'i':
                 settings->inputfile = optarg;
                 break;
             case 'v':
                 fprintf(stderr, "%s\n", dav1d_version());
                 exit(0);
             case 'u':
                 settings->untimed = true;
                 break;
             case ARG_HIGH_QUALITY:
                 settings->highquality = true;
                 break;
             case 'z':
                 settings->zerocopy = true;
                 break;
             case 'g':
                 settings->gpugrain = true;
                 break;
             case 'r':
                 settings->renderer_name = optarg;
                 break;
             case ARG_THREADS:
                 lib_settings->n_threads =
                     parse_unsigned(optarg, ARG_THREADS, argv[0]);
                 break;
             case ARG_FRAME_DELAY:
                 lib_settings->max_frame_delay =
                     parse_unsigned(optarg, ARG_FRAME_DELAY, argv[0]);
                 break;
             default:
                 dp_settings_print_usage(argv[0], NULL);
         }
     }

     if (optind < argc)
         dp_settings_print_usage(argv[0],
             "Extra/unused arguments found, e.g. '%s'\n", argv[optind]);
     if (!settings->inputfile)
         dp_settings_print_usage(argv[0], "Input file (-i/--input) is required");
     if (settings->renderer_name && strcmp(settings->renderer_name, "auto") == 0)
         settings->renderer_name = NULL;
 }

 /**
  * Destroy a Dav1dPlayRenderContext
  */
 static void dp_rd_ctx_destroy(Dav1dPlayRenderContext *rd_ctx)
 {
     assert(rd_ctx != NULL);

     renderer_info->destroy_renderer(rd_ctx->rd_priv);
     dp_fifo_destroy(rd_ctx->fifo);
     SDL_DestroyMutex(rd_ctx->lock);
     free(rd_ctx);
 }

 /**
  * Create a Dav1dPlayRenderContext
  *
  * \note  The Dav1dPlayRenderContext must be destroyed
  *        again by using dp_rd_ctx_destroy.
  */
 static Dav1dPlayRenderContext *dp_rd_ctx_create(int argc, char **argv)
 {
     Dav1dPlayRenderContext *rd_ctx;

     // Alloc
     rd_ctx = calloc(1, sizeof(Dav1dPlayRenderContext));
     if (rd_ctx == NULL) {
         return NULL;
     }

     // Register a custom event to notify our SDL main thread
     // about new frames
     rd_ctx->event_types = SDL_RegisterEvents(3);
     if (rd_ctx->event_types == UINT32_MAX) {
         fprintf(stderr, "Failure to create custom SDL event types!\n");
         free(rd_ctx);
         return NULL;
     }

     rd_ctx->fifo = dp_fifo_create(5);
     if (rd_ctx->fifo == NULL) {
         fprintf(stderr, "Failed to create FIFO for output pictures!\n");
         free(rd_ctx);
         return NULL;
     }

     rd_ctx->lock = SDL_CreateMutex();
     if (rd_ctx->lock == NULL) {
         fprintf(stderr, "SDL_CreateMutex failed: %s\n", SDL_GetError());
         dp_fifo_destroy(rd_ctx->fifo);
         free(rd_ctx);
         return NULL;
     }

     // Parse and validate arguments
     dav1d_default_settings(&rd_ctx->lib_settings);
     memset(&rd_ctx->settings, 0, sizeof(rd_ctx->settings));
     dp_rd_ctx_parse_args(rd_ctx, argc, argv);

     // Select renderer
     renderer_info = dp_get_renderer(rd_ctx->settings.renderer_name);

     if (renderer_info == NULL) {
         printf("No suitable renderer matching %s found.\n",
             (rd_ctx->settings.renderer_name) ? rd_ctx->settings.renderer_name : "auto");
     } else {
         printf("Using %s renderer\n", renderer_info->name);
     }

     rd_ctx->rd_priv = (renderer_info) ? renderer_info->create_renderer() : NULL;
     if (rd_ctx->rd_priv == NULL) {
         SDL_DestroyMutex(rd_ctx->lock);
         dp_fifo_destroy(rd_ctx->fifo);
         free(rd_ctx);
         return NULL;
     }

     return rd_ctx;
 }

 /**
  * Notify about new event
  */
 static void dp_rd_ctx_post_event(Dav1dPlayRenderContext *rd_ctx, uint32_t type)
 {
     SDL_Event event;
     SDL_zero(event);
     event.type = type;
     SDL_PushEvent(&event);
 }

 /**
  * Update the decoder context with a new dav1d picture
  *
  * Once the decoder decoded a new picture, this call can be used
  * to update the internal texture of the render context with the
  * new picture.
  */
 static void dp_rd_ctx_update_with_dav1d_picture(Dav1dPlayRenderContext *rd_ctx,
                                                 Dav1dPicture *dav1d_pic)
 {
     rd_ctx->current_ts = dav1d_pic->m.timestamp;
     renderer_info->update_frame(rd_ctx->rd_priv, dav1d_pic, &rd_ctx->settings);
 }

 /**
  * Toggle pause state
  */
 static void dp_rd_ctx_toggle_pause(Dav1dPlayRenderContext *rd_ctx)
 {
     SDL_LockMutex(rd_ctx->lock);
     rd_ctx->user_paused = !rd_ctx->user_paused;
     if (rd_ctx->seek)
         goto out;
     rd_ctx->paused = rd_ctx->user_paused;
     uint32_t now = SDL_GetTicks();
     if (rd_ctx->paused)
         rd_ctx->pause_start = now;
     else {
         rd_ctx->pause_time += now - rd_ctx->pause_start;
         rd_ctx->pause_start = 0;
         rd_ctx->last_ticks = now;
     }
 out:
     SDL_UnlockMutex(rd_ctx->lock);
 }

 /**
  * Query pause state
  */
 static int dp_rd_ctx_is_paused(Dav1dPlayRenderContext *rd_ctx)
 {
     int ret;
     SDL_LockMutex(rd_ctx->lock);
     ret = rd_ctx->paused;
     SDL_UnlockMutex(rd_ctx->lock);
     return ret;
 }

 /**
  * Request seeking, in seconds
  */
 static void dp_rd_ctx_seek(Dav1dPlayRenderContext *rd_ctx, int sec)
 {
     SDL_LockMutex(rd_ctx->lock);
     rd_ctx->seek += sec;
     if (!rd_ctx->paused)
         rd_ctx->pause_start = SDL_GetTicks();
     rd_ctx->paused = 1;
     SDL_UnlockMutex(rd_ctx->lock);
 }

 static int decode_frame(Dav1dPicture **p, Dav1dContext *c,
                         Dav1dData *data, DemuxerContext *in_ctx);
 static inline void destroy_pic(void *a);

 /**
  * Seek the stream, if requested
  */
 static int dp_rd_ctx_handle_seek(Dav1dPlayRenderContext *rd_ctx,
                                  DemuxerContext *in_ctx,
                                  Dav1dContext *c, Dav1dData *data)
 {
     int res = 0;
     SDL_LockMutex(rd_ctx->lock);
     if (!rd_ctx->seek)
         goto out;
     int64_t seek = rd_ctx->seek * 1000000000ULL;
     uint64_t pts = TS_TO_PTS(rd_ctx->current_ts);
     pts = ((int64_t)pts > -seek) ? pts + seek : 0;
     int end = pts >= FRAME_OFFSET_TO_PTS(rd_ctx->total);
     if (end)
         pts = FRAME_OFFSET_TO_PTS(rd_ctx->total - 1);
     uint64_t target_pts = pts;
     dav1d_flush(c);
     uint64_t shift = FRAME_OFFSET_TO_PTS(5);
     while (1) {
         if (shift > pts)
             shift = pts;
         if ((res = input_seek(in_ctx, pts - shift)))
             goto out;
         Dav1dSequenceHeader seq;
         uint64_t cur_pts;
         do {
             if ((res = input_read(in_ctx, data)))
                 break;
             cur_pts = TS_TO_PTS(data->m.timestamp);
             res = dav1d_parse_sequence_header(&seq, data->data, data->sz);
         } while (res && cur_pts < pts);
         if (!res && cur_pts <= pts)
             break;
         if (shift > pts)
             shift = pts;
         pts -= shift;
     }
     if (!res) {
         pts = TS_TO_PTS(data->m.timestamp);
         while (pts < target_pts) {
             Dav1dPicture *p;
             if ((res = decode_frame(&p, c, data, in_ctx)))
                 break;
             if (p) {
                 pts = TS_TO_PTS(p->m.timestamp);
                 if (pts < target_pts)
                     destroy_pic(p);
                 else {
                     dp_fifo_push(rd_ctx->fifo, p);
                     uint32_t type = rd_ctx->event_types + DAV1D_EVENT_SEEK_FRAME;
                     dp_rd_ctx_post_event(rd_ctx, type);
                 }
             }
         }
         if (!res) {
             rd_ctx->last_ts = data->m.timestamp - rd_ctx->spf / rd_ctx->timebase;
             rd_ctx->current_ts = data->m.timestamp;
         }
     }
 out:
     rd_ctx->paused = rd_ctx->user_paused;
     if (!rd_ctx->paused && rd_ctx->seek) {
         uint32_t now = SDL_GetTicks();
         rd_ctx->pause_time += now - rd_ctx->pause_start;
         rd_ctx->pause_start = 0;
         rd_ctx->last_ticks = now;
     }
     rd_ctx->seek = 0;
     SDL_UnlockMutex(rd_ctx->lock);
     if (res)
         fprintf(stderr, "Error seeking, aborting\n");
     return res;
 }

 /**
  * Terminate decoder thread (async)
  */
 static void dp_rd_ctx_request_shutdown(Dav1dPlayRenderContext *rd_ctx)
 {
     SDL_LockMutex(rd_ctx->lock);
     rd_ctx->dec_should_terminate = 1;
     SDL_UnlockMutex(rd_ctx->lock);
 }

 /**
  * Query state of decoder shutdown request
  */
 static int dp_rd_ctx_should_terminate(Dav1dPlayRenderContext *rd_ctx)
 {
     int ret = 0;
     SDL_LockMutex(rd_ctx->lock);
     ret = rd_ctx->dec_should_terminate;
     SDL_UnlockMutex(rd_ctx->lock);
     return ret;
 }

 /**
  * Render the currently available texture
  *
  * Renders the currently available texture, if any.
  */
 static void dp_rd_ctx_render(Dav1dPlayRenderContext *rd_ctx)
 {
     SDL_LockMutex(rd_ctx->lock);
     // Calculate time since last frame was received
     uint32_t ticks_now = SDL_GetTicks();
     uint32_t ticks_diff = (rd_ctx->last_ticks != 0) ? ticks_now - rd_ctx->last_ticks : 0;

     // Calculate when to display the frame
     int64_t ts_diff = rd_ctx->current_ts - rd_ctx->last_ts;
     int32_t pts_diff = (ts_diff * rd_ctx->timebase) * 1000.0 + .5;
     int32_t wait_time = pts_diff - ticks_diff;

     // In untimed mode, simply don't wait
     if (rd_ctx->settings.untimed)
         wait_time = 0;

     // This way of timing the playback is not accurate, as there is no guarantee
     // that SDL_Delay will wait for exactly the requested amount of time so in a
     // accurate player this would need to be done in a better way.
     if (wait_time > 0) {
         SDL_Delay(wait_time);
     } else if (wait_time < -10 && !rd_ctx->paused) { // Do not warn for minor time drifts
         fprintf(stderr, "Frame displayed %f seconds too late\n", wait_time / 1000.0);
     }

     renderer_info->render(rd_ctx->rd_priv, &rd_ctx->settings);

     rd_ctx->last_ts = rd_ctx->current_ts;
     rd_ctx->last_ticks = SDL_GetTicks();

     SDL_UnlockMutex(rd_ctx->lock);
 }

 static int decode_frame(Dav1dPicture **p, Dav1dContext *c,
                         Dav1dData *data, DemuxerContext *in_ctx)
 {
     int res;
     // Send data packets we got from the demuxer to dav1d
     if ((res = dav1d_send_data(c, data)) < 0) {
         // On EAGAIN, dav1d can not consume more data and
         // dav1d_get_picture needs to be called first, which
         // will happen below, so just keep going in that case
         // and do not error out.
         if (res != DAV1D_ERR(EAGAIN)) {
             dav1d_data_unref(data);
             goto err;
         }
     }
     *p = calloc(1, sizeof(**p));
     // Try to get a decoded frame
     if ((res = dav1d_get_picture(c, *p)) < 0) {
         // In all error cases, even EAGAIN, p needs to be freed as
         // it is never added to the queue and would leak.
         free(*p);
         *p = NULL;
         // On EAGAIN, it means dav1d has not enough data to decode
         // therefore this is not a decoding error but just means
         // we need to feed it more data, which happens in the next
         // run of the decoder loop.
         if (res != DAV1D_ERR(EAGAIN))
             goto err;
     }
     return data->sz == 0 ? input_read(in_ctx, data) : 0;
 err:
     fprintf(stderr, "Error decoding frame: %s\n",
             strerror(-res));
     return res;
 }

 static inline void destroy_pic(void *a)
 {
     Dav1dPicture *p = (Dav1dPicture *)a;
     dav1d_picture_unref(p);
     free(p);
 }

 /* Decoder thread "main" function */
 static int decoder_thread_main(void *cookie)
 {
     Dav1dPlayRenderContext *rd_ctx = cookie;

     Dav1dPicture *p;
     Dav1dContext *c = NULL;
     Dav1dData data;
     DemuxerContext *in_ctx = NULL;
     int res = 0;
     unsigned total, timebase[2], fps[2];

     Dav1dPlaySettings settings = rd_ctx->settings;

     if ((res = input_open(&in_ctx, "ivf",
                           settings.inputfile,
                           fps, &total, timebase)) < 0)
     {
         fprintf(stderr, "Failed to open demuxer\n");
         res = 1;
         goto cleanup;
     }

     rd_ctx->timebase = (double)timebase[1] / timebase[0];
     rd_ctx->spf = (double)fps[1] / fps[0];
     rd_ctx->total = total;

     if ((res = dav1d_open(&c, &rd_ctx->lib_settings))) {
         fprintf(stderr, "Failed opening dav1d decoder\n");
         res = 1;
         goto cleanup;
     }

     if ((res = input_read(in_ctx, &data)) < 0) {
         fprintf(stderr, "Failed demuxing input\n");
         res = 1;
         goto cleanup;
     }

     // Decoder loop
     while (1) {
         if (dp_rd_ctx_should_terminate(rd_ctx) ||
             (res = dp_rd_ctx_handle_seek(rd_ctx, in_ctx, c, &data)) ||
             (res = decode_frame(&p, c, &data, in_ctx)))
         {
             break;
         }
         else if (p) {
             // Queue frame
             SDL_LockMutex(rd_ctx->lock);
             int seek = rd_ctx->seek;
             SDL_UnlockMutex(rd_ctx->lock);
             if (!seek) {
                 dp_fifo_push(rd_ctx->fifo, p);
                 uint32_t type = rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME;
                 dp_rd_ctx_post_event(rd_ctx, type);
             }
         }
     }

     // Release remaining data
     if (data.sz > 0)
         dav1d_data_unref(&data);
     // Do not drain in case an error occured and caused us to leave the
     // decoding loop early.
     if (res < 0)
         goto cleanup;

     // Drain decoder
     // When there is no more data to feed to the decoder, for example
     // because the file ended, we still need to request pictures, as
     // even though we do not have more data, there can be frames decoded
     // from data we sent before. So we need to call dav1d_get_picture until
     // we get an EAGAIN error.
     do {
         if (dp_rd_ctx_should_terminate(rd_ctx))
             break;
         p = calloc(1, sizeof(*p));
         res = dav1d_get_picture(c, p);
         if (res < 0) {
             free(p);
             if (res != DAV1D_ERR(EAGAIN)) {
                 fprintf(stderr, "Error decoding frame: %s\n",
                         strerror(-res));
                 break;
             }
         } else {
             // Queue frame
             dp_fifo_push(rd_ctx->fifo, p);
             uint32_t type = rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME;
             dp_rd_ctx_post_event(rd_ctx, type);
         }
     } while (res != DAV1D_ERR(EAGAIN));

 cleanup:
     dp_rd_ctx_post_event(rd_ctx, rd_ctx->event_types + DAV1D_EVENT_DEC_QUIT);

     if (in_ctx)
         input_close(in_ctx);
     if (c)
         dav1d_close(&c);

     return (res != DAV1D_ERR(EAGAIN) && res < 0);
 }

 int main(int argc, char **argv)
 {
     SDL_Thread *decoder_thread;

     // Check for version mismatch between library and tool
     const char *version = dav1d_version();
     if (strcmp(version, DAV1D_VERSION)) {
         fprintf(stderr, "Version mismatch (library: %s, executable: %s)\n",
                 version, DAV1D_VERSION);
         return 1;
     }

     // Init SDL2 library
     if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
         return 10;

     // Create render context
     Dav1dPlayRenderContext *rd_ctx = dp_rd_ctx_create(argc, argv);
     if (rd_ctx == NULL) {
         fprintf(stderr, "Failed creating render context\n");
         return 5;
     }

     if (rd_ctx->settings.zerocopy) {
         if (renderer_info->alloc_pic) {
             rd_ctx->lib_settings.allocator = (Dav1dPicAllocator) {
                 .cookie = rd_ctx->rd_priv,
                 .alloc_picture_callback = renderer_info->alloc_pic,
                 .release_picture_callback = renderer_info->release_pic,
             };
         } else {
             fprintf(stderr, "--zerocopy unsupported by selected renderer\n");
         }
     }

     if (rd_ctx->settings.gpugrain) {
         if (renderer_info->supports_gpu_grain) {
             rd_ctx->lib_settings.apply_grain = 0;
         } else {
             fprintf(stderr, "--gpugrain unsupported by selected renderer\n");
         }
     }

     // Start decoder thread
     decoder_thread = SDL_CreateThread(decoder_thread_main, "Decoder thread", rd_ctx);

     // Main loop
 #define NUM_MAX_EVENTS 8
     SDL_Event events[NUM_MAX_EVENTS];
     int num_frame_events = 0;
     uint32_t start_time = 0, n_out = 0;
     while (1) {
         int num_events = 0;
         SDL_WaitEvent(NULL);
         while (num_events < NUM_MAX_EVENTS && SDL_PollEvent(&events[num_events++]))
             break;
         for (int i = 0; i < num_events; ++i) {
             SDL_Event *e = &events[i];
             if (e->type == SDL_QUIT) {
                 dp_rd_ctx_request_shutdown(rd_ctx);
                 dp_fifo_flush(rd_ctx->fifo, destroy_pic);
                 SDL_FlushEvent(rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME);
                 SDL_FlushEvent(rd_ctx->event_types + DAV1D_EVENT_SEEK_FRAME);
                 num_frame_events = 0;
             } else if (e->type == SDL_WINDOWEVENT) {
                 if (e->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
                     // TODO: Handle window resizes
                 } else if(e->window.event == SDL_WINDOWEVENT_EXPOSED) {
                     dp_rd_ctx_render(rd_ctx);
                 }
             } else if (e->type == SDL_KEYDOWN) {
                 SDL_KeyboardEvent *kbde = (SDL_KeyboardEvent *)e;
                 if (kbde->keysym.sym == SDLK_SPACE) {
                     dp_rd_ctx_toggle_pause(rd_ctx);
                 } else if (kbde->keysym.sym == SDLK_LEFT ||
                            kbde->keysym.sym == SDLK_RIGHT)
                 {
                     if (kbde->keysym.sym == SDLK_LEFT)
                         dp_rd_ctx_seek(rd_ctx, -5);
                     else if (kbde->keysym.sym == SDLK_RIGHT)
                         dp_rd_ctx_seek(rd_ctx, +5);
                     dp_fifo_flush(rd_ctx->fifo, destroy_pic);
                     SDL_FlushEvent(rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME);
                     num_frame_events = 0;
                 }
             } else if (e->type == rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME) {
                 num_frame_events++;
                 // Store current ticks for stats calculation
                 if (start_time == 0)
                     start_time = SDL_GetTicks();
             } else if (e->type == rd_ctx->event_types + DAV1D_EVENT_SEEK_FRAME) {
                 // Dequeue frame and update the render context with it
                 Dav1dPicture *p = dp_fifo_shift(rd_ctx->fifo);
                 // Do not update textures during termination
                 if (!dp_rd_ctx_should_terminate(rd_ctx)) {
                     dp_rd_ctx_update_with_dav1d_picture(rd_ctx, p);
                     n_out++;
                 }
                 destroy_pic(p);
             } else if (e->type == rd_ctx->event_types + DAV1D_EVENT_DEC_QUIT) {
                 goto out;
             }
         }
         if (num_frame_events && !dp_rd_ctx_is_paused(rd_ctx)) {
             // Dequeue frame and update the render context with it
             Dav1dPicture *p = dp_fifo_shift(rd_ctx->fifo);
             // Do not update textures during termination
             if (!dp_rd_ctx_should_terminate(rd_ctx)) {
                 dp_rd_ctx_update_with_dav1d_picture(rd_ctx, p);
                 dp_rd_ctx_render(rd_ctx);
                 n_out++;
             }
             destroy_pic(p);
             num_frame_events--;
         }
     }

 out:;
     // Print stats
     uint32_t time_ms = SDL_GetTicks() - start_time - rd_ctx->pause_time;
     printf("Decoded %u frames in %d seconds, avg %.02f fps\n",
            n_out, time_ms / 1000, n_out/ (time_ms / 1000.0));

     int decoder_ret = 0;
     SDL_WaitThread(decoder_thread, &decoder_ret);
     dp_rd_ctx_destroy(rd_ctx);
     return decoder_ret;
 }
	/*
	* Copyright © 2019, VideoLAN and dav1d authors
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice, this
	* list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
	* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "vcs_version.h"

	#include <getopt.h>
	#include <stdbool.h>

	#include <SDL.h>

	#include "dav1d/dav1d.h"

	#include "common/attributes.h"
	#include "tools/input/input.h"
	#include "dp_fifo.h"
	#include "dp_renderer.h"

	#define FRAME_OFFSET_TO_PTS(foff) \
	(uint64_t)(((foff) * rd_ctx->spf) * 1000000000.0 + .5)
	#define TS_TO_PTS(ts) \
	(uint64_t)(((ts) * rd_ctx->timebase) * 1000000000.0 + .5)

	// Selected renderer callbacks and cookie
	static const Dav1dPlayRenderInfo *renderer_info = { NULL };

	/**
	* Render context structure
	* This structure contains informations necessary
	* to be shared between the decoder and the renderer
	* threads.
	*/
	typedef struct render_context
	{
	Dav1dPlaySettings settings;
	Dav1dSettings lib_settings;

	// Renderer private data (passed to callbacks)
	void *rd_priv;

	// Lock to protect access to the context structure
	SDL_mutex *lock;

	// Timestamp of last displayed frame (in timebase unit)
	int64_t last_ts;
	// Timestamp of last decoded frame (in timebase unit)
	int64_t current_ts;
	// Ticks when last frame was received
	uint32_t last_ticks;
	// PTS time base
	double timebase;
	// Seconds per frame
	double spf;
	// Number of frames
	uint32_t total;

	// Fifo
	Dav1dPlayPtrFifo *fifo;

	// Custom SDL2 event types
	uint32_t event_types;

	// User pause state
	uint8_t user_paused;
	// Internal pause state
	uint8_t paused;
	// Start of internal pause state
	uint32_t pause_start;
	// Duration of internal pause state
	uint32_t pause_time;

	// Seek accumulator
	int seek;

	// Indicates if termination of the decoder thread was requested
	uint8_t dec_should_terminate;
	} Dav1dPlayRenderContext;

	static void dp_settings_print_usage(const char *const app,
	const char *const reason, ...)
	{
	if (reason) {
	va_list args;

	va_start(args, reason);
	vfprintf(stderr, reason, args);
	va_end(args);
	fprintf(stderr, "\n\n");
	}
	fprintf(stderr, "Usage: %s [options]\n\n", app);
	fprintf(stderr, "Supported options:\n"
	" --input/-i $file: input file\n"
	" --untimed/-u: ignore PTS, render as fast as possible\n"
	" --threads $num: number of threads (default: 0)\n"
	" --framedelay $num: maximum frame delay, capped at $threads (default: 0);\n"
	" set to 1 for low-latency decoding\n"
	" --highquality: enable high quality rendering\n"
	" --zerocopy/-z: enable zero copy upload path\n"
	" --gpugrain/-g: enable GPU grain synthesis\n"
	" --version/-v: print version and exit\n"
	" --renderer/-r: select renderer backend (default: auto)\n");
	exit(1);
	}

	static unsigned parse_unsigned(const char *const optarg, const int option,
	const char *const app)
	{
	char *end;
	const unsigned res = (unsigned) strtoul(optarg, &end, 0);
	if (*end \|\| end == optarg)
	dp_settings_print_usage(app, "Invalid argument \"%s\" for option %s; should be an integer",
	optarg, option);
	return res;
	}

	static void dp_rd_ctx_parse_args(Dav1dPlayRenderContext *rd_ctx,
	const int argc, char const const argv)
	{
	int o;
	Dav1dPlaySettings *settings = &rd_ctx->settings;
	Dav1dSettings *lib_settings = &rd_ctx->lib_settings;

	// Short options
	static const char short_opts[] = "i:vuzgr:";

	enum {
	ARG_THREADS = 256,
	ARG_FRAME_DELAY,
	ARG_HIGH_QUALITY,
	};

	// Long options
	static const struct option long_opts[] = {
	{ "input", 1, NULL, 'i' },
	{ "version", 0, NULL, 'v' },
	{ "untimed", 0, NULL, 'u' },
	{ "threads", 1, NULL, ARG_THREADS },
	{ "framedelay", 1, NULL, ARG_FRAME_DELAY },
	{ "highquality", 0, NULL, ARG_HIGH_QUALITY },
	{ "zerocopy", 0, NULL, 'z' },
	{ "gpugrain", 0, NULL, 'g' },
	{ "renderer", 0, NULL, 'r'},
	{ NULL, 0, NULL, 0 },
	};

	while ((o = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
	switch (o) {
	case 'i':
	settings->inputfile = optarg;
	break;
	case 'v':
	fprintf(stderr, "%s\n", dav1d_version());
	exit(0);
	case 'u':
	settings->untimed = true;
	break;
	case ARG_HIGH_QUALITY:
	settings->highquality = true;
	break;
	case 'z':
	settings->zerocopy = true;
	break;
	case 'g':
	settings->gpugrain = true;
	break;
	case 'r':
	settings->renderer_name = optarg;
	break;
	case ARG_THREADS:
	lib_settings->n_threads =
	parse_unsigned(optarg, ARG_THREADS, argv[0]);
	break;
	case ARG_FRAME_DELAY:
	lib_settings->max_frame_delay =
	parse_unsigned(optarg, ARG_FRAME_DELAY, argv[0]);
	break;
	default:
	dp_settings_print_usage(argv[0], NULL);
	}
	}

	if (optind < argc)
	dp_settings_print_usage(argv[0],
	"Extra/unused arguments found, e.g. '%s'\n", argv[optind]);
	if (!settings->inputfile)
	dp_settings_print_usage(argv[0], "Input file (-i/--input) is required");
	if (settings->renderer_name && strcmp(settings->renderer_name, "auto") == 0)
	settings->renderer_name = NULL;
	}

	/**
	* Destroy a Dav1dPlayRenderContext
	*/
	static void dp_rd_ctx_destroy(Dav1dPlayRenderContext *rd_ctx)
	{
	assert(rd_ctx != NULL);

	renderer_info->destroy_renderer(rd_ctx->rd_priv);
	dp_fifo_destroy(rd_ctx->fifo);
	SDL_DestroyMutex(rd_ctx->lock);
	free(rd_ctx);
	}

	/**
	* Create a Dav1dPlayRenderContext
	*
	* \note The Dav1dPlayRenderContext must be destroyed
	* again by using dp_rd_ctx_destroy.
	*/
	static Dav1dPlayRenderContext dp_rd_ctx_create(int argc, char *argv)
	{
	Dav1dPlayRenderContext *rd_ctx;

	// Alloc
	rd_ctx = calloc(1, sizeof(Dav1dPlayRenderContext));
	if (rd_ctx == NULL) {
	return NULL;
	}

	// Register a custom event to notify our SDL main thread
	// about new frames
	rd_ctx->event_types = SDL_RegisterEvents(3);
	if (rd_ctx->event_types == UINT32_MAX) {
	fprintf(stderr, "Failure to create custom SDL event types!\n");
	free(rd_ctx);
	return NULL;
	}

	rd_ctx->fifo = dp_fifo_create(5);
	if (rd_ctx->fifo == NULL) {
	fprintf(stderr, "Failed to create FIFO for output pictures!\n");
	free(rd_ctx);
	return NULL;
	}

	rd_ctx->lock = SDL_CreateMutex();
	if (rd_ctx->lock == NULL) {
	fprintf(stderr, "SDL_CreateMutex failed: %s\n", SDL_GetError());
	dp_fifo_destroy(rd_ctx->fifo);
	free(rd_ctx);
	return NULL;
	}

	// Parse and validate arguments
	dav1d_default_settings(&rd_ctx->lib_settings);
	memset(&rd_ctx->settings, 0, sizeof(rd_ctx->settings));
	dp_rd_ctx_parse_args(rd_ctx, argc, argv);

	// Select renderer
	renderer_info = dp_get_renderer(rd_ctx->settings.renderer_name);

	if (renderer_info == NULL) {
	printf("No suitable renderer matching %s found.\n",
	(rd_ctx->settings.renderer_name) ? rd_ctx->settings.renderer_name : "auto");
	} else {
	printf("Using %s renderer\n", renderer_info->name);
	}

	rd_ctx->rd_priv = (renderer_info) ? renderer_info->create_renderer() : NULL;
	if (rd_ctx->rd_priv == NULL) {
	SDL_DestroyMutex(rd_ctx->lock);
	dp_fifo_destroy(rd_ctx->fifo);
	free(rd_ctx);
	return NULL;
	}

	return rd_ctx;
	}

	/**
	* Notify about new event
	*/
	static void dp_rd_ctx_post_event(Dav1dPlayRenderContext *rd_ctx, uint32_t type)
	{
	SDL_Event event;
	SDL_zero(event);
	event.type = type;
	SDL_PushEvent(&event);
	}

	/**
	* Update the decoder context with a new dav1d picture
	*
	* Once the decoder decoded a new picture, this call can be used
	* to update the internal texture of the render context with the
	* new picture.
	*/
	static void dp_rd_ctx_update_with_dav1d_picture(Dav1dPlayRenderContext *rd_ctx,
	Dav1dPicture *dav1d_pic)
	{
	rd_ctx->current_ts = dav1d_pic->m.timestamp;
	renderer_info->update_frame(rd_ctx->rd_priv, dav1d_pic, &rd_ctx->settings);
	}

	/**
	* Toggle pause state
	*/
	static void dp_rd_ctx_toggle_pause(Dav1dPlayRenderContext *rd_ctx)
	{
	SDL_LockMutex(rd_ctx->lock);
	rd_ctx->user_paused = !rd_ctx->user_paused;
	if (rd_ctx->seek)
	goto out;
	rd_ctx->paused = rd_ctx->user_paused;
	uint32_t now = SDL_GetTicks();
	if (rd_ctx->paused)
	rd_ctx->pause_start = now;
	else {
	rd_ctx->pause_time += now - rd_ctx->pause_start;
	rd_ctx->pause_start = 0;
	rd_ctx->last_ticks = now;
	}
	out:
	SDL_UnlockMutex(rd_ctx->lock);
	}

	/**
	* Query pause state
	*/
	static int dp_rd_ctx_is_paused(Dav1dPlayRenderContext *rd_ctx)
	{
	int ret;
	SDL_LockMutex(rd_ctx->lock);
	ret = rd_ctx->paused;
	SDL_UnlockMutex(rd_ctx->lock);
	return ret;
	}

	/**
	* Request seeking, in seconds
	*/
	static void dp_rd_ctx_seek(Dav1dPlayRenderContext *rd_ctx, int sec)
	{
	SDL_LockMutex(rd_ctx->lock);
	rd_ctx->seek += sec;
	if (!rd_ctx->paused)
	rd_ctx->pause_start = SDL_GetTicks();
	rd_ctx->paused = 1;
	SDL_UnlockMutex(rd_ctx->lock);
	}

	static int decode_frame(Dav1dPicture *p, Dav1dContext c,
	Dav1dData data, DemuxerContext in_ctx);
	static inline void destroy_pic(void *a);

	/**
	* Seek the stream, if requested
	*/
	static int dp_rd_ctx_handle_seek(Dav1dPlayRenderContext *rd_ctx,
	DemuxerContext *in_ctx,
	Dav1dContext c, Dav1dData data)
	{
	int res = 0;
	SDL_LockMutex(rd_ctx->lock);
	if (!rd_ctx->seek)
	goto out;
	int64_t seek = rd_ctx->seek * 1000000000ULL;
	uint64_t pts = TS_TO_PTS(rd_ctx->current_ts);
	pts = ((int64_t)pts > -seek) ? pts + seek : 0;
	int end = pts >= FRAME_OFFSET_TO_PTS(rd_ctx->total);
	if (end)
	pts = FRAME_OFFSET_TO_PTS(rd_ctx->total - 1);
	uint64_t target_pts = pts;
	dav1d_flush(c);
	uint64_t shift = FRAME_OFFSET_TO_PTS(5);
	while (1) {
	if (shift > pts)
	shift = pts;
	if ((res = input_seek(in_ctx, pts - shift)))
	goto out;
	Dav1dSequenceHeader seq;
	uint64_t cur_pts;
	do {
	if ((res = input_read(in_ctx, data)))
	break;
	cur_pts = TS_TO_PTS(data->m.timestamp);
	res = dav1d_parse_sequence_header(&seq, data->data, data->sz);
	} while (res && cur_pts < pts);
	if (!res && cur_pts <= pts)
	break;
	if (shift > pts)
	shift = pts;
	pts -= shift;
	}
	if (!res) {
	pts = TS_TO_PTS(data->m.timestamp);
	while (pts < target_pts) {
	Dav1dPicture *p;
	if ((res = decode_frame(&p, c, data, in_ctx)))
	break;
	if (p) {
	pts = TS_TO_PTS(p->m.timestamp);
	if (pts < target_pts)
	destroy_pic(p);
	else {
	dp_fifo_push(rd_ctx->fifo, p);
	uint32_t type = rd_ctx->event_types + DAV1D_EVENT_SEEK_FRAME;
	dp_rd_ctx_post_event(rd_ctx, type);
	}
	}
	}
	if (!res) {
	rd_ctx->last_ts = data->m.timestamp - rd_ctx->spf / rd_ctx->timebase;
	rd_ctx->current_ts = data->m.timestamp;
	}
	}
	out:
	rd_ctx->paused = rd_ctx->user_paused;
	if (!rd_ctx->paused && rd_ctx->seek) {
	uint32_t now = SDL_GetTicks();
	rd_ctx->pause_time += now - rd_ctx->pause_start;
	rd_ctx->pause_start = 0;
	rd_ctx->last_ticks = now;
	}
	rd_ctx->seek = 0;
	SDL_UnlockMutex(rd_ctx->lock);
	if (res)
	fprintf(stderr, "Error seeking, aborting\n");
	return res;
	}

	/**
	* Terminate decoder thread (async)
	*/
	static void dp_rd_ctx_request_shutdown(Dav1dPlayRenderContext *rd_ctx)
	{
	SDL_LockMutex(rd_ctx->lock);
	rd_ctx->dec_should_terminate = 1;
	SDL_UnlockMutex(rd_ctx->lock);
	}

	/**
	* Query state of decoder shutdown request
	*/
	static int dp_rd_ctx_should_terminate(Dav1dPlayRenderContext *rd_ctx)
	{
	int ret = 0;
	SDL_LockMutex(rd_ctx->lock);
	ret = rd_ctx->dec_should_terminate;
	SDL_UnlockMutex(rd_ctx->lock);
	return ret;
	}

	/**
	* Render the currently available texture
	*
	* Renders the currently available texture, if any.
	*/
	static void dp_rd_ctx_render(Dav1dPlayRenderContext *rd_ctx)
	{
	SDL_LockMutex(rd_ctx->lock);
	// Calculate time since last frame was received
	uint32_t ticks_now = SDL_GetTicks();
	uint32_t ticks_diff = (rd_ctx->last_ticks != 0) ? ticks_now - rd_ctx->last_ticks : 0;

	// Calculate when to display the frame
	int64_t ts_diff = rd_ctx->current_ts - rd_ctx->last_ts;
	int32_t pts_diff = (ts_diff * rd_ctx->timebase) * 1000.0 + .5;
	int32_t wait_time = pts_diff - ticks_diff;

	// In untimed mode, simply don't wait
	if (rd_ctx->settings.untimed)
	wait_time = 0;

	// This way of timing the playback is not accurate, as there is no guarantee
	// that SDL_Delay will wait for exactly the requested amount of time so in a
	// accurate player this would need to be done in a better way.
	if (wait_time > 0) {
	SDL_Delay(wait_time);
	} else if (wait_time < -10 && !rd_ctx->paused) { // Do not warn for minor time drifts
	fprintf(stderr, "Frame displayed %f seconds too late\n", wait_time / 1000.0);
	}

	renderer_info->render(rd_ctx->rd_priv, &rd_ctx->settings);

	rd_ctx->last_ts = rd_ctx->current_ts;
	rd_ctx->last_ticks = SDL_GetTicks();

	SDL_UnlockMutex(rd_ctx->lock);
	}

	static int decode_frame(Dav1dPicture *p, Dav1dContext c,
	Dav1dData data, DemuxerContext in_ctx)
	{
	int res;
	// Send data packets we got from the demuxer to dav1d
	if ((res = dav1d_send_data(c, data)) < 0) {
	// On EAGAIN, dav1d can not consume more data and
	// dav1d_get_picture needs to be called first, which
	// will happen below, so just keep going in that case
	// and do not error out.
	if (res != DAV1D_ERR(EAGAIN)) {
	dav1d_data_unref(data);
	goto err;
	}
	}
	p = calloc(1, sizeof(*p));
	// Try to get a decoded frame
	if ((res = dav1d_get_picture(c, *p)) < 0) {
	// In all error cases, even EAGAIN, p needs to be freed as
	// it is never added to the queue and would leak.
	free(*p);
	*p = NULL;
	// On EAGAIN, it means dav1d has not enough data to decode
	// therefore this is not a decoding error but just means
	// we need to feed it more data, which happens in the next
	// run of the decoder loop.
	if (res != DAV1D_ERR(EAGAIN))
	goto err;
	}
	return data->sz == 0 ? input_read(in_ctx, data) : 0;
	err:
	fprintf(stderr, "Error decoding frame: %s\n",
	strerror(-res));
	return res;
	}

	static inline void destroy_pic(void *a)
	{
	Dav1dPicture p = (Dav1dPicture )a;
	dav1d_picture_unref(p);
	free(p);
	}

	/* Decoder thread "main" function */
	static int decoder_thread_main(void *cookie)
	{
	Dav1dPlayRenderContext *rd_ctx = cookie;

	Dav1dPicture *p;
	Dav1dContext *c = NULL;
	Dav1dData data;
	DemuxerContext *in_ctx = NULL;
	int res = 0;
	unsigned total, timebase[2], fps[2];

	Dav1dPlaySettings settings = rd_ctx->settings;

	if ((res = input_open(&in_ctx, "ivf",
	settings.inputfile,
	fps, &total, timebase)) < 0)
	{
	fprintf(stderr, "Failed to open demuxer\n");
	res = 1;
	goto cleanup;
	}

	rd_ctx->timebase = (double)timebase[1] / timebase[0];
	rd_ctx->spf = (double)fps[1] / fps[0];
	rd_ctx->total = total;

	if ((res = dav1d_open(&c, &rd_ctx->lib_settings))) {
	fprintf(stderr, "Failed opening dav1d decoder\n");
	res = 1;
	goto cleanup;
	}

	if ((res = input_read(in_ctx, &data)) < 0) {
	fprintf(stderr, "Failed demuxing input\n");
	res = 1;
	goto cleanup;
	}

	// Decoder loop
	while (1) {
	if (dp_rd_ctx_should_terminate(rd_ctx) \|\|
	(res = dp_rd_ctx_handle_seek(rd_ctx, in_ctx, c, &data)) \|\|
	(res = decode_frame(&p, c, &data, in_ctx)))
	{
	break;
	}
	else if (p) {
	// Queue frame
	SDL_LockMutex(rd_ctx->lock);
	int seek = rd_ctx->seek;
	SDL_UnlockMutex(rd_ctx->lock);
	if (!seek) {
	dp_fifo_push(rd_ctx->fifo, p);
	uint32_t type = rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME;
	dp_rd_ctx_post_event(rd_ctx, type);
	}
	}
	}

	// Release remaining data
	if (data.sz > 0)
	dav1d_data_unref(&data);
	// Do not drain in case an error occured and caused us to leave the
	// decoding loop early.
	if (res < 0)
	goto cleanup;

	// Drain decoder
	// When there is no more data to feed to the decoder, for example
	// because the file ended, we still need to request pictures, as
	// even though we do not have more data, there can be frames decoded
	// from data we sent before. So we need to call dav1d_get_picture until
	// we get an EAGAIN error.
	do {
	if (dp_rd_ctx_should_terminate(rd_ctx))
	break;
	p = calloc(1, sizeof(*p));
	res = dav1d_get_picture(c, p);
	if (res < 0) {
	free(p);
	if (res != DAV1D_ERR(EAGAIN)) {
	fprintf(stderr, "Error decoding frame: %s\n",
	strerror(-res));
	break;
	}
	} else {
	// Queue frame
	dp_fifo_push(rd_ctx->fifo, p);
	uint32_t type = rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME;
	dp_rd_ctx_post_event(rd_ctx, type);
	}
	} while (res != DAV1D_ERR(EAGAIN));

	cleanup:
	dp_rd_ctx_post_event(rd_ctx, rd_ctx->event_types + DAV1D_EVENT_DEC_QUIT);

	if (in_ctx)
	input_close(in_ctx);
	if (c)
	dav1d_close(&c);

	return (res != DAV1D_ERR(EAGAIN) && res < 0);
	}

	int main(int argc, char **argv)
	{
	SDL_Thread *decoder_thread;

	// Check for version mismatch between library and tool
	const char *version = dav1d_version();
	if (strcmp(version, DAV1D_VERSION)) {
	fprintf(stderr, "Version mismatch (library: %s, executable: %s)\n",
	version, DAV1D_VERSION);
	return 1;
	}

	// Init SDL2 library
	if (SDL_Init(SDL_INIT_VIDEO \| SDL_INIT_TIMER) < 0)
	return 10;

	// Create render context
	Dav1dPlayRenderContext *rd_ctx = dp_rd_ctx_create(argc, argv);
	if (rd_ctx == NULL) {
	fprintf(stderr, "Failed creating render context\n");
	return 5;
	}

	if (rd_ctx->settings.zerocopy) {
	if (renderer_info->alloc_pic) {
	rd_ctx->lib_settings.allocator = (Dav1dPicAllocator) {
	.cookie = rd_ctx->rd_priv,
	.alloc_picture_callback = renderer_info->alloc_pic,
	.release_picture_callback = renderer_info->release_pic,
	};
	} else {
	fprintf(stderr, "--zerocopy unsupported by selected renderer\n");
	}
	}

	if (rd_ctx->settings.gpugrain) {
	if (renderer_info->supports_gpu_grain) {
	rd_ctx->lib_settings.apply_grain = 0;
	} else {
	fprintf(stderr, "--gpugrain unsupported by selected renderer\n");
	}
	}

	// Start decoder thread
	decoder_thread = SDL_CreateThread(decoder_thread_main, "Decoder thread", rd_ctx);

	// Main loop
	#define NUM_MAX_EVENTS 8
	SDL_Event events[NUM_MAX_EVENTS];
	int num_frame_events = 0;
	uint32_t start_time = 0, n_out = 0;
	while (1) {
	int num_events = 0;
	SDL_WaitEvent(NULL);
	while (num_events < NUM_MAX_EVENTS && SDL_PollEvent(&events[num_events++]))
	break;
	for (int i = 0; i < num_events; ++i) {
	SDL_Event *e = &events[i];
	if (e->type == SDL_QUIT) {
	dp_rd_ctx_request_shutdown(rd_ctx);
	dp_fifo_flush(rd_ctx->fifo, destroy_pic);
	SDL_FlushEvent(rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME);
	SDL_FlushEvent(rd_ctx->event_types + DAV1D_EVENT_SEEK_FRAME);
	num_frame_events = 0;
	} else if (e->type == SDL_WINDOWEVENT) {
	if (e->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
	// TODO: Handle window resizes
	} else if(e->window.event == SDL_WINDOWEVENT_EXPOSED) {
	dp_rd_ctx_render(rd_ctx);
	}
	} else if (e->type == SDL_KEYDOWN) {
	SDL_KeyboardEvent kbde = (SDL_KeyboardEvent )e;
	if (kbde->keysym.sym == SDLK_SPACE) {
	dp_rd_ctx_toggle_pause(rd_ctx);
	} else if (kbde->keysym.sym == SDLK_LEFT \|\|
	kbde->keysym.sym == SDLK_RIGHT)
	{
	if (kbde->keysym.sym == SDLK_LEFT)
	dp_rd_ctx_seek(rd_ctx, -5);
	else if (kbde->keysym.sym == SDLK_RIGHT)
	dp_rd_ctx_seek(rd_ctx, +5);
	dp_fifo_flush(rd_ctx->fifo, destroy_pic);
	SDL_FlushEvent(rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME);
	num_frame_events = 0;
	}
	} else if (e->type == rd_ctx->event_types + DAV1D_EVENT_NEW_FRAME) {
	num_frame_events++;
	// Store current ticks for stats calculation
	if (start_time == 0)
	start_time = SDL_GetTicks();
	} else if (e->type == rd_ctx->event_types + DAV1D_EVENT_SEEK_FRAME) {
	// Dequeue frame and update the render context with it
	Dav1dPicture *p = dp_fifo_shift(rd_ctx->fifo);
	// Do not update textures during termination
	if (!dp_rd_ctx_should_terminate(rd_ctx)) {
	dp_rd_ctx_update_with_dav1d_picture(rd_ctx, p);
	n_out++;
	}
	destroy_pic(p);
	} else if (e->type == rd_ctx->event_types + DAV1D_EVENT_DEC_QUIT) {
	goto out;
	}
	}
	if (num_frame_events && !dp_rd_ctx_is_paused(rd_ctx)) {
	// Dequeue frame and update the render context with it
	Dav1dPicture *p = dp_fifo_shift(rd_ctx->fifo);
	// Do not update textures during termination
	if (!dp_rd_ctx_should_terminate(rd_ctx)) {
	dp_rd_ctx_update_with_dav1d_picture(rd_ctx, p);
	dp_rd_ctx_render(rd_ctx);
	n_out++;
	}
	destroy_pic(p);
	num_frame_events--;
	}
	}

	out:;
	// Print stats
	uint32_t time_ms = SDL_GetTicks() - start_time - rd_ctx->pause_time;
	printf("Decoded %u frames in %d seconds, avg %.02f fps\n",
	n_out, time_ms / 1000, n_out/ (time_ms / 1000.0));

	int decoder_ret = 0;
	SDL_WaitThread(decoder_thread, &decoder_ret);
	dp_rd_ctx_destroy(rd_ctx);
	return decoder_ret;
	}