ref: 3a77c57b0ca06c613fea96afe63d2870f513e97f
parent: 42ea146f847d761b91d66d4db2c5a6341fefee75
author: James Almer <jamrial@gmail.com>
date: Fri Aug 9 12:56:00 EDT 2019
meson: move dav1dplay to a new examples section dav1dplay shouldn't be built by default. And it's an example more than a tool.
--- /dev/null
+++ b/examples/dav1dplay.c
@@ -1,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 <string.h>
+#include <assert.h>
+#include <getopt.h>
+
+#include <SDL.h>
+
+
+#include "dav1d/dav1d.h"
+
+#include "tools/input/input.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 <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;
+}
--- /dev/null
+++ b/examples/meson.build
@@ -1,0 +1,62 @@
+# Copyright © 2018, 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.
+
+#
+# Build definition for the dav1d examples
+#
+
+# Leave subdir if examples are disabled
+if not get_option('enable_examples')+ subdir_done()
+endif
+
+
+# dav1d player sources
+dav1dplay_sources = files(
+ 'dav1dplay.c',
+)
+
+sdl2_dependency = dependency('sdl2', version: '>= 2.0.1', required: false)+
+if sdl2_dependency.found()
+ placebo_dependency = dependency('libplacebo', version: '>= 1.18.0', required: false)+ vulkan_dependency = dependency('vulkan', required: false)+ sdl_has_vulkan = cc.has_header('SDL_vulkan.h', dependencies: [sdl2_dependency])+ cflag_placebo = []
+ deps_placebo = []
+ if placebo_dependency.found() and vulkan_dependency.found() and sdl_has_vulkan
+ cflag_placebo += '-DHAVE_PLACEBO_VULKAN=1'
+ deps_placebo = [vulkan_dependency, placebo_dependency]
+ endif
+ dav1dplay = executable('dav1dplay',+ dav1dplay_sources,
+ rev_target,
+
+ link_with : [libdav1d, dav1d_input_objs],
+ include_directories : [dav1d_inc_dirs],
+ dependencies : [getopt_dependency, sdl2_dependency, deps_placebo],
+ install : true,
+ c_args : cflag_placebo,
+ )
+endif
--- a/meson.build
+++ b/meson.build
@@ -394,4 +394,6 @@
subdir('tools')+subdir('examples')+
subdir('tests')--- a/meson_options.txt
+++ b/meson_options.txt
@@ -15,6 +15,11 @@
value: true,
description: 'Build dav1d cli tools')
+option('enable_examples',+ type: 'boolean',
+ value: false,
+ description: 'Build dav1d examples')
+
option('enable_tests',type: 'boolean',
value: true,
--- a/tools/dav1dplay.c
+++ /dev/null
@@ -1,1085 +1,0 @@
-/*
- * 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 <string.h>
-#include <assert.h>
-#include <getopt.h>
-
-#include <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 <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;
-}
--- a/tools/meson.build
+++ b/tools/meson.build
@@ -22,10 +22,39 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-# Build definition for the dav1d tools
-#
+# Common source files used by tools and examples
+dav1d_input_sources = files(
+ 'input/input.c',
+ 'input/annexb.c',
+ 'input/ivf.c',
+)
+
+dav1d_output_sources = files(
+ 'output/md5.c',
+ 'output/null.c',
+ 'output/output.c',
+ 'output/y4m2.c',
+ 'output/yuv.c',
+)
+
+dav1d_input_objs = static_library('dav1d_input',+ dav1d_input_sources,
+
+ include_directories : dav1d_inc_dirs,
+ install : false,
+ build_by_default : false,
+)
+
+dav1d_output_objs = static_library('dav1d_output',+ dav1d_output_sources,
+
+ include_directories : dav1d_inc_dirs,
+ install : false,
+ build_by_default : false,
+)
+
+
# Leave subdir if tools are disabled
if not get_option('enable_tools')subdir_done()
@@ -32,6 +61,10 @@
endif
+#
+# Build definition for the dav1d tools
+#
+
# Configuratin data for cli_config.h
cli_cdata = configuration_data()
@@ -56,14 +89,6 @@
dav1d_sources = files(
'dav1d.c',
'dav1d_cli_parse.c',
- 'input/input.c',
- 'input/annexb.c',
- 'input/ivf.c',
- 'output/md5.c',
- 'output/null.c',
- 'output/output.c',
- 'output/y4m2.c',
- 'output/yuv.c',
)
dav1d = executable('dav1d',@@ -70,41 +95,8 @@
dav1d_sources,
rev_target, cli_config_h_target,
- link_with : libdav1d,
+ link_with : [libdav1d, dav1d_input_objs, dav1d_output_objs],
include_directories : [dav1d_inc_dirs],
dependencies : [getopt_dependency, thread_dependency, rt_dependency],
install : true,
)
-
-
-# dav1d player sources
-dav1dplay_sources = files(
- 'dav1dplay.c',
- 'input/input.c',
- 'input/annexb.c',
- 'input/ivf.c',
-)
-
-sdl2_dependency = dependency('sdl2', version: '>= 2.0.1', required: false)-
-if sdl2_dependency.found()
- placebo_dependency = dependency('libplacebo', version: '>= 1.18.0', required: false)- vulkan_dependency = dependency('vulkan', required: false)- sdl_has_vulkan = cc.has_header('SDL_vulkan.h', dependencies: [sdl2_dependency])- cflag_placebo = []
- deps_placebo = []
- if placebo_dependency.found() and vulkan_dependency.found() and sdl_has_vulkan
- cflag_placebo += '-DHAVE_PLACEBO_VULKAN=1'
- deps_placebo = [vulkan_dependency, placebo_dependency]
- endif
- dav1dplay = executable('dav1dplay',- dav1dplay_sources,
- rev_target,
-
- link_with : libdav1d,
- include_directories : [dav1d_inc_dirs],
- dependencies : [getopt_dependency, sdl2_dependency, deps_placebo],
- install : true,
- c_args : cflag_placebo,
- )
-endif