diff options
Diffstat (limited to 'tools/dav1dplay.c')
-rw-r--r-- | tools/dav1dplay.c | 1084 |
1 files changed, 1084 insertions, 0 deletions
diff --git a/tools/dav1dplay.c b/tools/dav1dplay.c new file mode 100644 index 0000000..b06d07a --- /dev/null +++ b/tools/dav1dplay.c @@ -0,0 +1,1084 @@ +/* + * 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 <stdio.h> +#include <stdint.h> +#include <assert.h> +#include <getopt.h> + +#include <SDL2/SDL.h> + + +#include "dav1d/dav1d.h" + +#include "input/input.h" +#include "dav1d_cli_parse.h" + +/** + * Settings structure + * Hold all settings available for the player, + * this is usually filled by parsing arguments + * from the console. + */ +typedef struct { + const char *inputfile; +} Dav1dPlaySettings; + +#define WINDOW_WIDTH 910 +#define WINDOW_HEIGHT 512 + +#define DAV1D_EVENT_NEW_FRAME 1 +#define DAV1D_EVENT_DEC_QUIT 2 + +/* + * Fifo helper functions + */ +typedef struct dp_fifo +{ + SDL_mutex *lock; + SDL_cond *cond_change; + size_t capacity; + size_t count; + void **entries; +} Dav1dPlayPtrFifo; + +static void dp_fifo_destroy(Dav1dPlayPtrFifo *fifo) +{ + assert(fifo->count == 0); + SDL_DestroyMutex(fifo->lock); + SDL_DestroyCond(fifo->cond_change); + free(fifo->entries); + free(fifo); +} + +static Dav1dPlayPtrFifo *dp_fifo_create(size_t capacity) +{ + Dav1dPlayPtrFifo *fifo; + + assert(capacity > 0); + if (capacity <= 0) + return NULL; + + fifo = malloc(sizeof(*fifo)); + if (fifo == NULL) + return NULL; + + fifo->capacity = capacity; + fifo->count = 0; + + fifo->lock = SDL_CreateMutex(); + if (fifo->lock == NULL) { + free(fifo); + return NULL; + } + fifo->cond_change = SDL_CreateCond(); + if (fifo->cond_change == NULL) { + SDL_DestroyMutex(fifo->lock); + free(fifo); + return NULL; + } + + fifo->entries = calloc(capacity, sizeof(void*)); + if (fifo->entries == NULL) { + dp_fifo_destroy(fifo); + return NULL; + } + + return fifo; +} + +static void dp_fifo_push(Dav1dPlayPtrFifo *fifo, void *element) +{ + SDL_LockMutex(fifo->lock); + while (fifo->count == fifo->capacity) + SDL_CondWait(fifo->cond_change, fifo->lock); + fifo->entries[fifo->count++] = element; + if (fifo->count == 1) + SDL_CondSignal(fifo->cond_change); + SDL_UnlockMutex(fifo->lock); +} + +static void *dp_fifo_array_shift(void **arr, size_t len) +{ + void *shifted_element = arr[0]; + for (size_t i = 1; i < len; ++i) + arr[i-1] = arr[i]; + return shifted_element; +} + +static void *dp_fifo_shift(Dav1dPlayPtrFifo *fifo) +{ + SDL_LockMutex(fifo->lock); + while (fifo->count == 0) + SDL_CondWait(fifo->cond_change, fifo->lock); + void *res = dp_fifo_array_shift(fifo->entries, fifo->count--); + if (fifo->count == fifo->capacity - 1) + SDL_CondSignal(fifo->cond_change); + SDL_UnlockMutex(fifo->lock); + return res; +} + +/** + * Renderer info + */ +typedef struct rdr_info +{ + // Cookie passed to the renderer implementation callbacks + void *cookie; + // Callback to create the renderer + void* (*create_renderer)(void *data); + // Callback to destroy the renderer + void (*destroy_renderer)(void *cookie); + // Callback to the render function that renders a prevously sent frame + void (*render)(void *cookie); + // Callback to the send frame function + int (*update_frame)(void *cookie, Dav1dPicture *dav1d_pic); +} Dav1dPlayRenderInfo; + +#ifdef HAVE_PLACEBO_VULKAN + +#include <libplacebo/renderer.h> +#include <libplacebo/utils/upload.h> +#include <libplacebo/vulkan.h> +#include <SDL2/SDL_vulkan.h> + + +/** + * Renderer context for libplacebo + */ +typedef struct renderer_priv_ctx +{ + // Placebo context + struct pl_context *ctx; + // Placebo renderer + struct pl_renderer *renderer; + // Placebo Vulkan handle + const struct pl_vulkan *vk; + // Placebo Vulkan instance + const struct pl_vk_inst *vk_inst; + // Vulkan surface + VkSurfaceKHR surf; + // Placebo swapchain + const struct pl_swapchain *swapchain; + // Lock protecting access to the texture + SDL_mutex *lock; + // Planes to render + struct pl_plane y_plane; + struct pl_plane u_plane; + struct pl_plane v_plane; + // Textures to render + const struct pl_tex *y_tex; + const struct pl_tex *u_tex; + const struct pl_tex *v_tex; +} Dav1dPlayRendererPrivateContext; + +static void *placebo_renderer_create(void *data) +{ + // Alloc + Dav1dPlayRendererPrivateContext *rd_priv_ctx = malloc(sizeof(Dav1dPlayRendererPrivateContext)); + if (rd_priv_ctx == NULL) { + return NULL; + } + + // Init libplacebo + rd_priv_ctx->ctx = pl_context_create(PL_API_VER, &(struct pl_context_params) { + .log_cb = pl_log_color, +#ifndef NDEBUG + .log_level = PL_LOG_DEBUG, +#else + .log_level = PL_LOG_WARN, +#endif + }); + if (rd_priv_ctx->ctx == NULL) { + free(rd_priv_ctx); + return NULL; + } + + // Create Mutex + rd_priv_ctx->lock = SDL_CreateMutex(); + if (rd_priv_ctx->lock == NULL) { + fprintf(stderr, "SDL_CreateMutex failed: %s\n", SDL_GetError()); + pl_context_destroy(&(rd_priv_ctx->ctx)); + free(rd_priv_ctx); + return NULL; + } + + // Init Vulkan + struct pl_vk_inst_params iparams = pl_vk_inst_default_params; + + SDL_Window *sdlwin = data; + + unsigned num = 0; + if (!SDL_Vulkan_GetInstanceExtensions(sdlwin, &num, NULL)) { + fprintf(stderr, "Failed enumerating Vulkan extensions: %s\n", SDL_GetError()); + exit(1); + } + + iparams.extensions = malloc(num * sizeof(const char *)); + iparams.num_extensions = num; + assert(iparams.extensions); + + SDL_bool ok = SDL_Vulkan_GetInstanceExtensions(sdlwin, &num, iparams.extensions); + if (!ok) { + fprintf(stderr, "Failed getting Vk instance extensions\n"); + exit(1); + } + + if (num > 0) { + printf("Requesting %d additional Vulkan extensions:\n", num); + for (unsigned i = 0; i < num; i++) + printf(" %s\n", iparams.extensions[i]); + } + + rd_priv_ctx->vk_inst = pl_vk_inst_create(rd_priv_ctx->ctx, &iparams); + if (!rd_priv_ctx->vk_inst) { + fprintf(stderr, "Failed creating Vulkan instance!\n"); + exit(1); + } + free(iparams.extensions); + + if (!SDL_Vulkan_CreateSurface(sdlwin, rd_priv_ctx->vk_inst->instance, &rd_priv_ctx->surf)) { + fprintf(stderr, "Failed creating vulkan surface: %s\n", SDL_GetError()); + exit(1); + } + + struct pl_vulkan_params params = pl_vulkan_default_params; + params.instance = rd_priv_ctx->vk_inst->instance; + params.surface = rd_priv_ctx->surf; + params.allow_software = true; + + rd_priv_ctx->vk = pl_vulkan_create(rd_priv_ctx->ctx, ¶ms); + if (!rd_priv_ctx->vk) { + fprintf(stderr, "Failed creating vulkan device!\n"); + exit(2); + } + + // Create swapchain + rd_priv_ctx->swapchain = pl_vulkan_create_swapchain(rd_priv_ctx->vk, + &(struct pl_vulkan_swapchain_params) { + .surface = rd_priv_ctx->surf, + .present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR, + }); + + if (!rd_priv_ctx->swapchain) { + fprintf(stderr, "Failed creating vulkan swapchain!\n"); + exit(2); + } + + int w = WINDOW_WIDTH, h = WINDOW_HEIGHT; + if (!pl_swapchain_resize(rd_priv_ctx->swapchain, &w, &h)) { + fprintf(stderr, "Failed resizing vulkan swapchain!\n"); + exit(2); + } + + if (w != WINDOW_WIDTH || h != WINDOW_HEIGHT) + printf("Note: window dimensions differ (got %dx%d)\n", w, h); + + rd_priv_ctx->y_tex = NULL; + rd_priv_ctx->u_tex = NULL; + rd_priv_ctx->v_tex = NULL; + + rd_priv_ctx->renderer = NULL; + + return rd_priv_ctx; +} + +static void placebo_renderer_destroy(void *cookie) +{ + Dav1dPlayRendererPrivateContext *rd_priv_ctx = cookie; + assert(rd_priv_ctx != NULL); + + pl_renderer_destroy(&(rd_priv_ctx->renderer)); + pl_tex_destroy(rd_priv_ctx->vk->gpu, &(rd_priv_ctx->y_tex)); + pl_tex_destroy(rd_priv_ctx->vk->gpu, &(rd_priv_ctx->u_tex)); + pl_tex_destroy(rd_priv_ctx->vk->gpu, &(rd_priv_ctx->v_tex)); + pl_swapchain_destroy(&(rd_priv_ctx->swapchain)); + pl_vulkan_destroy(&(rd_priv_ctx->vk)); + vkDestroySurfaceKHR(rd_priv_ctx->vk_inst->instance, rd_priv_ctx->surf, NULL); + pl_vk_inst_destroy(&(rd_priv_ctx->vk_inst)); + pl_context_destroy(&(rd_priv_ctx->ctx)); +} + +static void placebo_render(void *cookie) +{ + Dav1dPlayRendererPrivateContext *rd_priv_ctx = cookie; + assert(rd_priv_ctx != NULL); + + SDL_LockMutex(rd_priv_ctx->lock); + if (rd_priv_ctx->y_tex == NULL) { + SDL_UnlockMutex(rd_priv_ctx->lock); + return; + } + + // Prepare rendering + if (rd_priv_ctx->renderer == NULL) { + rd_priv_ctx->renderer = pl_renderer_create(rd_priv_ctx->ctx, rd_priv_ctx->vk->gpu); + } + + struct pl_swapchain_frame frame; + bool ok = pl_swapchain_start_frame(rd_priv_ctx->swapchain, &frame); + if (!ok) { + SDL_UnlockMutex(rd_priv_ctx->lock); + return; + } + + const struct pl_tex *img = rd_priv_ctx->y_plane.texture; + struct pl_image image = { + .num_planes = 3, + .planes = { rd_priv_ctx->y_plane, rd_priv_ctx->u_plane, rd_priv_ctx->v_plane }, + .repr = pl_color_repr_hdtv, + .color = pl_color_space_unknown, + .width = img->params.w, + .height = img->params.h, + }; + + struct pl_render_params render_params = pl_render_default_params; + //render_params.upscaler = &pl_filter_ewa_lanczos; + + struct pl_render_target target; + pl_render_target_from_swapchain(&target, &frame); + target.profile = (struct pl_icc_profile) { + .data = NULL, + .len = 0, + }; + + if (!pl_render_image(rd_priv_ctx->renderer, &image, &target, &render_params)) { + fprintf(stderr, "Failed rendering frame!\n"); + SDL_UnlockMutex(rd_priv_ctx->lock); + return; + } + + ok = pl_swapchain_submit_frame(rd_priv_ctx->swapchain); + if (!ok) { + fprintf(stderr, "Failed submitting frame!\n"); + SDL_UnlockMutex(rd_priv_ctx->lock); + return; + } + + pl_swapchain_swap_buffers(rd_priv_ctx->swapchain); + SDL_UnlockMutex(rd_priv_ctx->lock); +} + +static int placebo_upload_planes(void *cookie, Dav1dPicture *dav1d_pic) +{ + Dav1dPlayRendererPrivateContext *rd_priv_ctx = cookie; + assert(rd_priv_ctx != NULL); + + SDL_LockMutex(rd_priv_ctx->lock); + + if (dav1d_pic == NULL) { + SDL_UnlockMutex(rd_priv_ctx->lock); + return 0; + } + + int width = dav1d_pic->p.w; + int height = dav1d_pic->p.h; + + enum Dav1dPixelLayout dav1d_layout = dav1d_pic->p.layout; + + if (DAV1D_PIXEL_LAYOUT_I420 != dav1d_layout || dav1d_pic->p.bpc != 8) { + fprintf(stderr, "Unsupported pixel format, only 8bit 420 supported so far.\n"); + exit(50); + } + + struct pl_plane_data data_y = { + .type = PL_FMT_UNORM, + .width = width, + .height = height, + .pixel_stride = 1, + .row_stride = dav1d_pic->stride[0], + .pixels = dav1d_pic->data[0], + .component_size = {8}, + .component_map = {0}, + }; + + struct pl_plane_data data_u = { + .type = PL_FMT_UNORM, + .width = width/2, + .height = height/2, + .pixel_stride = 1, + .row_stride = dav1d_pic->stride[1], + .pixels = dav1d_pic->data[1], + .component_size = {8}, + .component_map = {1}, + }; + + struct pl_plane_data data_v = { + .type = PL_FMT_UNORM, + .width = width/2, + .height = height/2, + .pixel_stride = 1, + .row_stride = dav1d_pic->stride[1], + .pixels = dav1d_pic->data[2], + .component_size = {8}, + .component_map = {2}, + }; + + bool ok = true; + ok &= pl_upload_plane(rd_priv_ctx->vk->gpu, &(rd_priv_ctx->y_plane), &(rd_priv_ctx->y_tex), &data_y); + ok &= pl_upload_plane(rd_priv_ctx->vk->gpu, &(rd_priv_ctx->u_plane), &(rd_priv_ctx->u_tex), &data_u); + ok &= pl_upload_plane(rd_priv_ctx->vk->gpu, &(rd_priv_ctx->v_plane), &(rd_priv_ctx->v_tex), &data_v); + + pl_chroma_location_offset(PL_CHROMA_LEFT, &rd_priv_ctx->u_plane.shift_x, &rd_priv_ctx->u_plane.shift_y); + pl_chroma_location_offset(PL_CHROMA_LEFT, &rd_priv_ctx->v_plane.shift_x, &rd_priv_ctx->v_plane.shift_y); + + if (!ok) { + fprintf(stderr, "Failed uploading planes!\n"); + } + + SDL_UnlockMutex(rd_priv_ctx->lock); + return !ok; +} + +static const Dav1dPlayRenderInfo renderer_info = { + .create_renderer = placebo_renderer_create, + .destroy_renderer = placebo_renderer_destroy, + .render = placebo_render, + .update_frame = placebo_upload_planes +}; + +#else + +/** + * Renderer context for SDL + */ +typedef struct renderer_priv_ctx +{ + // SDL renderer + SDL_Renderer *renderer; + // Lock protecting access to the texture + SDL_mutex *lock; + // Texture to render + SDL_Texture *tex; +} Dav1dPlayRendererPrivateContext; + +static void *sdl_renderer_create(void *data) +{ + SDL_Window *win = data; + + // Alloc + Dav1dPlayRendererPrivateContext *rd_priv_ctx = malloc(sizeof(Dav1dPlayRendererPrivateContext)); + if (rd_priv_ctx == NULL) { + return NULL; + } + + // Create renderer + rd_priv_ctx->renderer = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED); + // Set scale quality + SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); + + // Create Mutex + rd_priv_ctx->lock = SDL_CreateMutex(); + if (rd_priv_ctx->lock == NULL) { + fprintf(stderr, "SDL_CreateMutex failed: %s\n", SDL_GetError()); + free(rd_priv_ctx); + return NULL; + } + + rd_priv_ctx->tex = NULL; + + return rd_priv_ctx; +} + +static void sdl_renderer_destroy(void *cookie) +{ + Dav1dPlayRendererPrivateContext *rd_priv_ctx = cookie; + assert(rd_priv_ctx != NULL); + + SDL_DestroyRenderer(rd_priv_ctx->renderer); + SDL_DestroyMutex(rd_priv_ctx->lock); + free(rd_priv_ctx); +} + +static void sdl_render(void *cookie) +{ + Dav1dPlayRendererPrivateContext *rd_priv_ctx = cookie; + assert(rd_priv_ctx != NULL); + + SDL_LockMutex(rd_priv_ctx->lock); + + if (rd_priv_ctx->tex == NULL) { + SDL_UnlockMutex(rd_priv_ctx->lock); + return; + } + + // Display the frame + SDL_RenderClear(rd_priv_ctx->renderer); + SDL_RenderCopy(rd_priv_ctx->renderer, rd_priv_ctx->tex, NULL, NULL); + SDL_RenderPresent(rd_priv_ctx->renderer); + + SDL_UnlockMutex(rd_priv_ctx->lock); +} + +static int sdl_update_texture(void *cookie, Dav1dPicture *dav1d_pic) +{ + Dav1dPlayRendererPrivateContext *rd_priv_ctx = cookie; + assert(rd_priv_ctx != NULL); + + SDL_LockMutex(rd_priv_ctx->lock); + + if (dav1d_pic == NULL) { + rd_priv_ctx->tex = NULL; + SDL_UnlockMutex(rd_priv_ctx->lock); + return 0; + } + + int width = dav1d_pic->p.w; + int height = dav1d_pic->p.h; + int tex_w = width; + int tex_h = height; + + enum Dav1dPixelLayout dav1d_layout = dav1d_pic->p.layout; + + if (DAV1D_PIXEL_LAYOUT_I420 != dav1d_layout || dav1d_pic->p.bpc != 8) { + fprintf(stderr, "Unsupported pixel format, only 8bit 420 supported so far.\n"); + exit(50); + } + + SDL_Texture *texture = rd_priv_ctx->tex; + if (texture != NULL) { + SDL_QueryTexture(texture, NULL, NULL, &tex_w, &tex_h); + if (tex_w != width || tex_h != height) { + SDL_DestroyTexture(texture); + texture = NULL; + } + } + + if (texture == NULL) { + texture = SDL_CreateTexture(rd_priv_ctx->renderer, SDL_PIXELFORMAT_IYUV, + SDL_TEXTUREACCESS_STREAMING, width, height); + } + + SDL_UpdateYUVTexture(texture, NULL, + dav1d_pic->data[0], (int)dav1d_pic->stride[0], // Y + dav1d_pic->data[1], (int)dav1d_pic->stride[1], // U + dav1d_pic->data[2], (int)dav1d_pic->stride[1] // V + ); + + rd_priv_ctx->tex = texture; + SDL_UnlockMutex(rd_priv_ctx->lock); + return 0; +} + +static const Dav1dPlayRenderInfo renderer_info = { + .create_renderer = sdl_renderer_create, + .destroy_renderer = sdl_renderer_destroy, + .render = sdl_render, + .update_frame = sdl_update_texture +}; + +#endif + +/** + * 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 callbacks + Dav1dPlayRenderInfo *renderer_info; + // Renderer private data (passed to callbacks) + void *rd_priv; + + // Lock to protect access to the context structure + SDL_mutex *lock; + + // Timestamp of previous decoded frame + int64_t last_pts; + // Timestamp of current decoded frame + int64_t current_pts; + // Ticks when last frame was received + uint32_t last_ticks; + // PTS time base + double timebase; + + // Fifo + Dav1dPlayPtrFifo *fifo; + + // Custom SDL2 event type + uint32_t renderer_event_type; + + // 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" + " --framethreads $num: number of frame threads (default: 1)\n" + " --tilethreads $num: number of tile threads (default: 1)\n" + " --version/-v: print version and exit\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:v"; + + enum { + ARG_FRAME_THREADS = 256, + ARG_TILE_THREADS, + }; + + // Long options + static const struct option long_opts[] = { + { "input", 1, NULL, 'i' }, + { "version", 0, NULL, 'v' }, + { "framethreads", 1, NULL, ARG_FRAME_THREADS }, + { "tilethreads", 1, NULL, ARG_TILE_THREADS }, + { 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 ARG_FRAME_THREADS: + lib_settings->n_frame_threads = + parse_unsigned(optarg, ARG_FRAME_THREADS, argv[0]); + break; + case ARG_TILE_THREADS: + lib_settings->n_tile_threads = + parse_unsigned(optarg, ARG_TILE_THREADS, 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]); +} + +/** + * 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(void *rd_data) +{ + Dav1dPlayRenderContext *rd_ctx; + + // Alloc + rd_ctx = malloc(sizeof(Dav1dPlayRenderContext)); + if (rd_ctx == NULL) { + return NULL; + } + + // Register a custom event to notify our SDL main thread + // about new frames + rd_ctx->renderer_event_type = SDL_RegisterEvents(1); + if (rd_ctx->renderer_event_type == UINT32_MAX) { + fprintf(stderr, "Failure to create custom SDL event type!\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; + } + + rd_ctx->rd_priv = renderer_info.create_renderer(rd_data); + if (rd_ctx->rd_priv == NULL) { + SDL_DestroyMutex(rd_ctx->lock); + dp_fifo_destroy(rd_ctx->fifo); + free(rd_ctx); + return NULL; + } + + dav1d_default_settings(&rd_ctx->lib_settings); + + rd_ctx->last_pts = 0; + rd_ctx->last_ticks = 0; + rd_ctx->current_pts = 0; + rd_ctx->timebase = 0; + rd_ctx->dec_should_terminate = 0; + + return rd_ctx; +} + +/** + * Notify about new available frame + */ +static void dp_rd_ctx_post_event(Dav1dPlayRenderContext *rd_ctx, uint32_t code) +{ + SDL_Event event; + SDL_zero(event); + event.type = rd_ctx->renderer_event_type; + event.user.code = code; + 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) +{ + renderer_info.update_frame(rd_ctx->rd_priv, dav1d_pic); + rd_ctx->current_pts = dav1d_pic->m.timestamp; +} + +/** + * 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) +{ + // 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 pts_diff = rd_ctx->current_pts - rd_ctx->last_pts; + int32_t wait_time = (pts_diff * rd_ctx->timebase) * 1000 - ticks_diff; + rd_ctx->last_pts = rd_ctx->current_pts; + + // 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) { // Do not warn for minor time drifts + fprintf(stderr, "Frame displayed %f seconds too late\n", wait_time/(float)1000); + } + + renderer_info.render(rd_ctx->rd_priv); + + rd_ctx->last_ticks = SDL_GetTicks(); +} + +/* 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 n_out = 0, total, timebase[2], fps[2]; + + // Store current ticks for stats calculation + uint32_t decoder_start = SDL_GetTicks(); + + Dav1dPlaySettings settings = rd_ctx->settings; + + // Init dav1d tools demuxers + init_demuxers(); + + if ((res = input_open(&in_ctx, "ivf", + settings.inputfile, + fps, &total, timebase)) < 0) + { + fprintf(stderr, "Failed to open demuxer\n"); + res = 1; + goto cleanup; + } + + double timebase_d = timebase[1]/(double)timebase[0]; + rd_ctx->timebase = timebase_d; + + 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 + do { + if (dp_rd_ctx_should_terminate(rd_ctx)) + break; + + // 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); + fprintf(stderr, "Error decoding frame: %s\n", + strerror(-res)); + break; + } + } + + 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); + + // 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 this decoder loop. + if (res != DAV1D_ERR(EAGAIN)) { + fprintf(stderr, "Error decoding frame: %s\n", + strerror(-res)); + break; + } + res = 0; + } else { + + // Queue frame + dp_fifo_push(rd_ctx->fifo, p); + dp_rd_ctx_post_event(rd_ctx, DAV1D_EVENT_NEW_FRAME); + + n_out++; + } + } while ((data.sz > 0 || !input_read(in_ctx, &data))); + + // 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); + dp_rd_ctx_post_event(rd_ctx, DAV1D_EVENT_NEW_FRAME); + + n_out++; + } + } while (res != DAV1D_ERR(EAGAIN)); + + // Print stats + uint32_t decoding_time_ms = SDL_GetTicks() - decoder_start; + printf("Decoded %u frames in %d seconds, avg %.02f fps\n", + n_out, decoding_time_ms/1000, n_out / (decoding_time_ms / 1000.0)); + +cleanup: + dp_rd_ctx_post_event(rd_ctx, 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; + SDL_Window *win = NULL; + + // 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 Window and Renderer + int window_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI; +#ifdef HAVE_PLACEBO_VULKAN + window_flags |= SDL_WINDOW_VULKAN; +#endif + win = SDL_CreateWindow("Dav1dPlay", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, + WINDOW_WIDTH, WINDOW_HEIGHT, window_flags); + SDL_SetWindowResizable(win, SDL_TRUE); + + // Create render context + Dav1dPlayRenderContext *rd_ctx = dp_rd_ctx_create(win); + if (rd_ctx == NULL) { + fprintf(stderr, "Failed creating render context\n"); + return 5; + } + + // Parse and validate arguments + dp_rd_ctx_parse_args(rd_ctx, argc, argv); + + // Start decoder thread + decoder_thread = SDL_CreateThread(decoder_thread_main, "Decoder thread", rd_ctx); + + // Main loop + while (1) { + + SDL_Event e; + if (SDL_WaitEvent(&e)) { + if (e.type == SDL_QUIT) { + dp_rd_ctx_request_shutdown(rd_ctx); + } else if (e.type == rd_ctx->renderer_event_type) { + if (e.user.code == DAV1D_EVENT_NEW_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); + dav1d_picture_unref(p); + free(p); + } else if (e.user.code == DAV1D_EVENT_DEC_QUIT) { + break; + } + } + } + + // Do not render during termination + if (!dp_rd_ctx_should_terminate(rd_ctx)) + dp_rd_ctx_render(rd_ctx); + } + + int decoder_ret = 0; + SDL_WaitThread(decoder_thread, &decoder_ret); + + dp_rd_ctx_destroy(rd_ctx); + SDL_DestroyWindow(win); + + return decoder_ret; +} |