[vlc-commits] thumbnailer: use vlc_executor_t
Romain Vimont
git at videolan.org
Fri Oct 23 17:48:07 CEST 2020
vlc | branch: master | Romain Vimont <rom1v at videolabs.io> | Fri Sep 4 13:21:18 2020 +0200| [adfe2249db3cd9fd4b8e568ba3a9dadd9d107768] | committer: Alexandre Janniaux
thumbnailer: use vlc_executor_t
Replace the background worker by an executor.
Signed-off-by: Alexandre Janniaux <ajanni at videolabs.io>
> http://git.videolan.org/gitweb.cgi/vlc.git/?a=commit;h=adfe2249db3cd9fd4b8e568ba3a9dadd9d107768
---
src/input/thumbnailer.c | 392 +++++++++++++++++++++++++++---------------------
1 file changed, 225 insertions(+), 167 deletions(-)
diff --git a/src/input/thumbnailer.c b/src/input/thumbnailer.c
index 783eb2886b..c063cfecf4 100644
--- a/src/input/thumbnailer.c
+++ b/src/input/thumbnailer.c
@@ -25,49 +25,120 @@
#endif
#include <vlc_thumbnailer.h>
+#include <vlc_executor.h>
#include "input_internal.h"
-#include "misc/background_worker.h"
struct vlc_thumbnailer_t
{
vlc_object_t* parent;
- struct background_worker* worker;
+ vlc_executor_t *executor;
+
+ vlc_mutex_t lock;
+ struct vlc_list submitted_tasks; /**< list of struct thumbnailer_task */
};
-typedef struct vlc_thumbnailer_params_t
+struct seek_target
{
- union
- {
- vlc_tick_t time;
- float pos;
- };
enum
{
VLC_THUMBNAILER_SEEK_TIME,
VLC_THUMBNAILER_SEEK_POS,
} type;
+ union
+ {
+ vlc_tick_t time;
+ float pos;
+ };
+};
+
+/* We may not rename vlc_thumbnailer_request_t because it is exposed in the
+ * public API */
+typedef struct vlc_thumbnailer_request_t task_t;
+
+struct vlc_thumbnailer_request_t
+{
+ vlc_thumbnailer_t *thumbnailer;
+
+ struct seek_target seek_target;
bool fast_seek;
- input_item_t* input_item;
+ input_item_t *item;
/**
* A positive value will be used as the timeout duration
* VLC_TICK_INVALID means no timeout
*/
vlc_tick_t timeout;
vlc_thumbnailer_cb cb;
- void* user_data;
-} vlc_thumbnailer_params_t;
+ void* userdata;
-struct vlc_thumbnailer_request_t
-{
- vlc_thumbnailer_t *thumbnailer;
- input_thread_t *input_thread;
+ vlc_mutex_t lock;
+ vlc_cond_t cond_ended;
+ bool ended;
- vlc_thumbnailer_params_t params;
+ struct vlc_runnable runnable; /**< to be passed to the executor */
- vlc_mutex_t lock;
- bool done;
+ struct vlc_list node; /**< node of vlc_thumbnailer_t.submitted_tasks */
};
+static void RunnableRun(void *);
+
+static task_t *
+TaskNew(vlc_thumbnailer_t *thumbnailer, input_item_t *item,
+ struct seek_target seek_target, bool fast_seek,
+ vlc_thumbnailer_cb cb, void *userdata, vlc_tick_t timeout)
+{
+ task_t *task = malloc(sizeof(*task));
+ if (!task)
+ return NULL;
+
+ task->thumbnailer = thumbnailer;
+ task->item = item;
+ task->seek_target = seek_target;
+ task->fast_seek = fast_seek;
+ task->cb = cb;
+ task->userdata = userdata;
+ task->timeout = timeout;
+
+ vlc_mutex_init(&task->lock);
+ vlc_cond_init(&task->cond_ended);
+ task->ended = false;
+
+ task->runnable.run = RunnableRun;
+ task->runnable.userdata = task;
+
+ input_item_Hold(item);
+
+ return task;
+}
+
+static void
+TaskDelete(task_t *task)
+{
+ input_item_Release(task->item);
+ free(task);
+}
+
+static void
+ThumbnailerAddTask(vlc_thumbnailer_t *thumbnailer, task_t *task)
+{
+ vlc_mutex_lock(&thumbnailer->lock);
+ vlc_list_append(&task->node, &thumbnailer->submitted_tasks);
+ vlc_mutex_unlock(&thumbnailer->lock);
+}
+
+static void
+ThumbnailerRemoveTask(vlc_thumbnailer_t *thumbnailer, task_t *task)
+{
+ vlc_mutex_lock(&thumbnailer->lock);
+ vlc_list_remove(&task->node);
+ vlc_mutex_unlock(&thumbnailer->lock);
+}
+
+static void NotifyThumbnail(task_t *task, picture_t *pic)
+{
+ assert(task->cb);
+ task->cb(task->userdata, pic);
+}
+
static void
on_thumbnailer_input_event( input_thread_t *input,
const struct vlc_input_event *event, void *userdata )
@@ -78,181 +149,148 @@ on_thumbnailer_input_event( input_thread_t *input,
event->state.value != END_S ) ) )
return;
- vlc_thumbnailer_request_t* request = userdata;
- picture_t *pic = NULL;
+ task_t *task = userdata;
- if ( event->type == INPUT_EVENT_THUMBNAIL_READY )
+ vlc_mutex_lock(&task->lock);
+ if (task->ended)
{
- /*
- * Stop the input thread ASAP, delegate its release to
- * thumbnailer_request_Release
- */
- input_Stop( request->input_thread );
- pic = event->thumbnail;
- }
- vlc_mutex_lock( &request->lock );
- request->done = true;
- /*
- * If the request has not been cancelled, we can invoke the completion
- * callback.
- */
- if ( request->params.cb )
- {
- request->params.cb( request->params.user_data, pic );
- request->params.cb = NULL;
+ /* We may receive a THUMBNAIL_READY event followed by an
+ * INPUT_EVENT_STATE (end of stream), we must only consider the first
+ * one. */
+ vlc_mutex_unlock(&task->lock);
+ return;
}
- vlc_mutex_unlock( &request->lock );
- background_worker_RequestProbe( request->thumbnailer->worker );
-}
-static void thumbnailer_request_Hold( void* data )
-{
- VLC_UNUSED(data);
-}
+ task->ended = true;
+ vlc_mutex_unlock(&task->lock);
-static void thumbnailer_request_Release( void* data )
-{
- vlc_thumbnailer_request_t* request = data;
- if ( request->input_thread )
- input_Close( request->input_thread );
+ picture_t *pic = NULL;
+ if (event->type == INPUT_EVENT_THUMBNAIL_READY)
+ pic = event->thumbnail;
- input_item_Release( request->params.input_item );
- free( request );
+ NotifyThumbnail(task, pic);
+ vlc_cond_signal(&task->cond_ended);
}
-static int thumbnailer_request_Start( void* owner, void* entity, void** out )
+static void
+RunnableRun(void *userdata)
{
- vlc_thumbnailer_t* thumbnailer = owner;
- vlc_thumbnailer_request_t* request = entity;
- input_thread_t* input = request->input_thread =
- input_CreateThumbnailer( thumbnailer->parent,
- on_thumbnailer_input_event, request,
- request->params.input_item );
- if ( unlikely( input == NULL ) )
+ task_t *task = userdata;
+ vlc_thumbnailer_t *thumbnailer = task->thumbnailer;
+
+ vlc_tick_t now = vlc_tick_now();
+
+ input_thread_t* input =
+ input_CreateThumbnailer(thumbnailer->parent, on_thumbnailer_input_event,
+ task, task->item);
+ if (!input)
+ goto end;
+
+ if (task->seek_target.type == VLC_THUMBNAILER_SEEK_TIME)
+ input_SetTime(input, task->seek_target.time, task->fast_seek);
+ else
{
- request->params.cb( request->params.user_data, NULL );
- return VLC_EGENERIC;
+ assert(task->seek_target.type == VLC_THUMBNAILER_SEEK_POS);
+ input_SetPosition(input, task->seek_target.pos, task->fast_seek);
}
- if ( request->params.type == VLC_THUMBNAILER_SEEK_TIME )
+
+ int ret = input_Start(input);
+ if (ret != VLC_SUCCESS)
{
- input_SetTime( input, request->params.time,
- request->params.fast_seek );
+ input_Close(input);
+ goto end;
}
- else
+
+ vlc_mutex_lock(&task->lock);
+ if (task->timeout == VLC_TICK_INVALID)
{
- assert( request->params.type == VLC_THUMBNAILER_SEEK_POS );
- input_SetPosition( input, request->params.pos,
- request->params.fast_seek );
+ while (!task->ended)
+ vlc_cond_wait(&task->cond_ended, &task->lock);
}
- if ( input_Start( input ) != VLC_SUCCESS )
+ else
{
- request->params.cb( request->params.user_data, NULL );
- return VLC_EGENERIC;
+ vlc_tick_t deadline = now + task->timeout;
+ bool timeout = false;
+ while (!task->ended && !timeout)
+ timeout =
+ vlc_cond_timedwait(&task->cond_ended, &task->lock, deadline);
}
- *out = request;
- return VLC_SUCCESS;
-}
+ vlc_mutex_unlock(&task->lock);
-static void thumbnailer_request_Stop( void* owner, void* handle )
-{
- VLC_UNUSED(owner);
+ input_Stop(input);
+ input_Close(input);
- vlc_thumbnailer_request_t *request = handle;
- vlc_mutex_lock( &request->lock );
- /*
- * If the callback hasn't been invoked yet, we assume a timeout and
- * signal it back to the user
- */
- if ( request->params.cb != NULL )
- {
- request->params.cb( request->params.user_data, NULL );
- request->params.cb = NULL;
- }
- vlc_mutex_unlock( &request->lock );
- assert( request->input_thread != NULL );
- input_Stop( request->input_thread );
+end:
+ ThumbnailerRemoveTask(thumbnailer, task);
+ TaskDelete(task);
}
-static int thumbnailer_request_Probe( void* owner, void* handle )
+static void
+Interrupt(task_t *task)
{
- VLC_UNUSED(owner);
- vlc_thumbnailer_request_t *request = handle;
- vlc_mutex_lock( &request->lock );
- int res = request->done;
- vlc_mutex_unlock( &request->lock );
- return res;
+ /* Wake up RunnableRun() which will call input_Stop() */
+ vlc_mutex_lock(&task->lock);
+ task->ended = true;
+ vlc_mutex_unlock(&task->lock);
+ vlc_cond_signal(&task->cond_ended);
}
-static vlc_thumbnailer_request_t*
-thumbnailer_RequestCommon( vlc_thumbnailer_t* thumbnailer,
- const vlc_thumbnailer_params_t* params )
+static task_t *
+RequestCommon(vlc_thumbnailer_t *thumbnailer, struct seek_target seek_target,
+ enum vlc_thumbnailer_seek_speed speed, input_item_t *item,
+ vlc_tick_t timeout, vlc_thumbnailer_cb cb, void *userdata)
{
- vlc_thumbnailer_request_t *request = malloc( sizeof( *request ) );
- if ( unlikely( request == NULL ) )
+ bool fast_seek = speed == VLC_THUMBNAILER_SEEK_FAST;
+ task_t *task = TaskNew(thumbnailer, item, seek_target, fast_seek, cb,
+ userdata, timeout);
+ if (!task)
return NULL;
- request->thumbnailer = thumbnailer;
- request->input_thread = NULL;
- request->params = *(vlc_thumbnailer_params_t*)params;
- request->done = false;
- input_item_Hold( request->params.input_item );
- vlc_mutex_init( &request->lock );
-
- int timeout = params->timeout == VLC_TICK_INVALID ?
- 0 : MS_FROM_VLC_TICK( params->timeout );
- if ( background_worker_Push( thumbnailer->worker, request, request,
- timeout ) != VLC_SUCCESS )
- {
- thumbnailer_request_Release( request );
- return NULL;
- }
- return request;
+
+ ThumbnailerAddTask(thumbnailer, task);
+
+ vlc_executor_Submit(thumbnailer->executor, &task->runnable);
+
+ /* XXX In theory, "task" might already be invalid here (if it is already
+ * executed and deleted). This is consistent with the API documentation and
+ * the previous implementation, but it is not very convenient for the user.
+ */
+ return task;
}
-vlc_thumbnailer_request_t*
+task_t *
vlc_thumbnailer_RequestByTime( vlc_thumbnailer_t *thumbnailer,
vlc_tick_t time,
enum vlc_thumbnailer_seek_speed speed,
- input_item_t *input_item, vlc_tick_t timeout,
- vlc_thumbnailer_cb cb, void* user_data )
+ input_item_t *item, vlc_tick_t timeout,
+ vlc_thumbnailer_cb cb, void* userdata )
{
- return thumbnailer_RequestCommon( thumbnailer,
- &(const vlc_thumbnailer_params_t){
- .time = time,
- .type = VLC_THUMBNAILER_SEEK_TIME,
- .fast_seek = speed == VLC_THUMBNAILER_SEEK_FAST,
- .input_item = input_item,
- .timeout = timeout,
- .cb = cb,
- .user_data = user_data,
- });
+ struct seek_target seek_target = {
+ .type = VLC_THUMBNAILER_SEEK_TIME,
+ .time = time,
+ };
+ return RequestCommon(thumbnailer, seek_target, speed, item, timeout, cb,
+ userdata);
}
-vlc_thumbnailer_request_t*
+task_t *
vlc_thumbnailer_RequestByPos( vlc_thumbnailer_t *thumbnailer,
float pos, enum vlc_thumbnailer_seek_speed speed,
- input_item_t *input_item, vlc_tick_t timeout,
- vlc_thumbnailer_cb cb, void* user_data )
+ input_item_t *item, vlc_tick_t timeout,
+ vlc_thumbnailer_cb cb, void* userdata )
{
- return thumbnailer_RequestCommon( thumbnailer,
- &(const vlc_thumbnailer_params_t){
- .pos = pos,
- .type = VLC_THUMBNAILER_SEEK_POS,
- .fast_seek = speed == VLC_THUMBNAILER_SEEK_FAST,
- .input_item = input_item,
- .timeout = timeout,
- .cb = cb,
- .user_data = user_data,
- });
+ struct seek_target seek_target = {
+ .type = VLC_THUMBNAILER_SEEK_POS,
+ .time = pos,
+ };
+ return RequestCommon(thumbnailer, seek_target, speed, item, timeout, cb,
+ userdata);
}
-void vlc_thumbnailer_Cancel( vlc_thumbnailer_t* thumbnailer,
- vlc_thumbnailer_request_t* req )
+void vlc_thumbnailer_Cancel( vlc_thumbnailer_t* thumbnailer, task_t* task )
{
- vlc_mutex_lock( &req->lock );
- /* Ensure we won't invoke the callback if the input was running. */
- req->params.cb = NULL;
- vlc_mutex_unlock( &req->lock );
- background_worker_Cancel( thumbnailer->worker, req );
+ (void) thumbnailer;
+ /* The API documentation requires that task is valid */
+ Interrupt(task);
}
vlc_thumbnailer_t *vlc_thumbnailer_Create( vlc_object_t* parent)
@@ -260,27 +298,47 @@ vlc_thumbnailer_t *vlc_thumbnailer_Create( vlc_object_t* parent)
vlc_thumbnailer_t *thumbnailer = malloc( sizeof( *thumbnailer ) );
if ( unlikely( thumbnailer == NULL ) )
return NULL;
- thumbnailer->parent = parent;
- struct background_worker_config cfg = {
- .default_timeout = -1,
- .max_threads = 1,
- .pf_release = thumbnailer_request_Release,
- .pf_hold = thumbnailer_request_Hold,
- .pf_start = thumbnailer_request_Start,
- .pf_probe = thumbnailer_request_Probe,
- .pf_stop = thumbnailer_request_Stop,
- };
- thumbnailer->worker = background_worker_New( thumbnailer, &cfg );
- if ( unlikely( thumbnailer->worker == NULL ) )
+
+ thumbnailer->executor = vlc_executor_New(1);
+ if (!thumbnailer->executor)
{
- free( thumbnailer );
+ free(thumbnailer);
return NULL;
}
+
+ thumbnailer->parent = parent;
+ vlc_mutex_init(&thumbnailer->lock);
+ vlc_list_init(&thumbnailer->submitted_tasks);
+
return thumbnailer;
}
+static void
+CancelAllTasks(vlc_thumbnailer_t *thumbnailer)
+{
+ vlc_mutex_lock(&thumbnailer->lock);
+
+ task_t *task;
+ vlc_list_foreach(task, &thumbnailer->submitted_tasks, node)
+ {
+ bool canceled = vlc_executor_Cancel(thumbnailer->executor,
+ &task->runnable);
+ if (canceled)
+ {
+ NotifyThumbnail(task, NULL);
+ vlc_list_remove(&task->node);
+ TaskDelete(task);
+ }
+ /* Otherwise, the task will be finished and destroyed after run() */
+ }
+
+ vlc_mutex_unlock(&thumbnailer->lock);
+}
+
void vlc_thumbnailer_Release( vlc_thumbnailer_t *thumbnailer )
{
- background_worker_Delete( thumbnailer->worker );
+ CancelAllTasks(thumbnailer);
+
+ vlc_executor_Delete(thumbnailer->executor);
free( thumbnailer );
}
More information about the vlc-commits
mailing list