From 9c56be26dcdb5f32584c5e7e810a7884a9ad4fff Mon Sep 17 00:00:00 2001 From: Marvin Scholz Date: Tue, 28 Apr 2020 17:47:17 +0200 Subject: Dav1dPlay: Split FIFO to different files To un-clutter the main dav1dplay.c, move the fifo to its own file and header. --- examples/dav1dplay.c | 88 +----------------------------------- examples/dp_fifo.c | 123 +++++++++++++++++++++++++++++++++++++++++++++++++++ examples/dp_fifo.h | 61 +++++++++++++++++++++++++ examples/meson.build | 1 + 4 files changed, 186 insertions(+), 87 deletions(-) create mode 100644 examples/dp_fifo.c create mode 100644 examples/dp_fifo.h (limited to 'examples') diff --git a/examples/dav1dplay.c b/examples/dav1dplay.c index bcd4835..cc873d0 100644 --- a/examples/dav1dplay.c +++ b/examples/dav1dplay.c @@ -40,6 +40,7 @@ #include "dav1d/dav1d.h" #include "tools/input/input.h" +#include "dp_fifo.h" /** * Settings structure @@ -60,93 +61,6 @@ typedef struct { #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 diff --git a/examples/dp_fifo.c b/examples/dp_fifo.c new file mode 100644 index 0000000..243d2e9 --- /dev/null +++ b/examples/dp_fifo.c @@ -0,0 +1,123 @@ +/* + * 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 +#include + +#include "dp_fifo.h" + +// FIFO structure +struct dp_fifo +{ + SDL_mutex *lock; + SDL_cond *cond_change; + size_t capacity; + size_t count; + void **entries; +}; + + +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; +} + +// Destroy FIFO +void dp_fifo_destroy(Dav1dPlayPtrFifo *fifo) +{ + assert(fifo->count == 0); + SDL_DestroyMutex(fifo->lock); + SDL_DestroyCond(fifo->cond_change); + free(fifo->entries); + free(fifo); +} + +// Push to FIFO +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); +} + +// Helper that shifts the FIFO array +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; +} + +// Get item from FIFO +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; +} + + diff --git a/examples/dp_fifo.h b/examples/dp_fifo.h new file mode 100644 index 0000000..a94b089 --- /dev/null +++ b/examples/dp_fifo.h @@ -0,0 +1,61 @@ +/* + * 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. + */ + +/* + * Dav1dPlay FIFO helper + */ + +typedef struct dp_fifo Dav1dPlayPtrFifo; + +/* Create a FIFO + * + * Creates a FIFO with the given capacity. + * If the capacity is reached, new inserts into the FIFO + * will block until enough space is available again. + */ +Dav1dPlayPtrFifo *dp_fifo_create(size_t capacity); + +/* Destroy a FIFO + * + * The FIFO must be empty before it is destroyed! + */ +void dp_fifo_destroy(Dav1dPlayPtrFifo *fifo); + +/* Shift FIFO + * + * Return the first item from the FIFO, thereby removing it from + * the FIFO and making room for new entries. + */ +void *dp_fifo_shift(Dav1dPlayPtrFifo *fifo); + +/* Push to FIFO + * + * Add an item to the end of the FIFO. + * If the FIFO is full, this call will block until there is again enough + * space in the FIFO, so calling this from the "consumer" thread if no + * other thread will call dp_fifo_shift will lead to a deadlock. + */ +void dp_fifo_push(Dav1dPlayPtrFifo *fifo, void *element); diff --git a/examples/meson.build b/examples/meson.build index bad1d90..0e856d0 100644 --- a/examples/meson.build +++ b/examples/meson.build @@ -35,6 +35,7 @@ endif # dav1d player sources dav1dplay_sources = files( 'dav1dplay.c', + 'dp_fifo.c', ) sdl2_dependency = dependency('sdl2', version: '>= 2.0.1', required: true) -- cgit v1.2.3