preparser: use vlc_preparser_req pointer for request identification

Remove vlc_preparser_req_id

include/vlc_media_source.h

@@ -236,10 +236,10 @@ vlc_media_tree_Find(vlc_media_tree_t *tree, const input_item_t *media,
  * \param tree   the media tree (not necessarily locked)
  * \param parser a valid preparser
  * \param media  the media to preparse
- * \returns VLC_PREPARSER_REQ_ID_INVALID in case of error, or a valid id if the
+ * \returns NULL in case of error, or a valid request handle if the
  * item was scheduled for preparsing. Cancel it vlc_preparser_Cancel().
  */
-VLC_API vlc_preparser_req_id
+VLC_API vlc_preparser_req *
 vlc_media_tree_Preparse(vlc_media_tree_t *tree, vlc_preparser_t *parser,
                         input_item_t *media);
 

include/vlc_preparser.h

@@ -42,9 +42,15 @@
  * It will also issue art fetching requests.
  */
 typedef struct vlc_preparser_t vlc_preparser_t;
-typedef size_t vlc_preparser_req_id;
 
-#define VLC_PREPARSER_REQ_ID_INVALID 0
+/**
+ * Preparser request opaque handle.
+ *
+ * Identifies a request submitted via vlc_preparser_Push(),
+ * vlc_preparser_GenerateThumbnail(), or vlc_preparser_GenerateThumbnailToFiles().
+ * It can be passed to vlc_preparser_Cancel() to cancel that request.
+ */
+typedef struct vlc_preparser_req vlc_preparser_req;
 
 #define VLC_PREPARSER_TYPE_PARSE            0x01
 #define VLC_PREPARSER_TYPE_FETCHMETA_LOCAL  0x02
@@ -270,11 +276,11 @@ VLC_API vlc_preparser_t *vlc_preparser_New( vlc_object_t *obj,
  * @param cbs_userdata opaque pointer used by the callbacks
  * @param id unique id provided by the caller. This is can be used to cancel
  * the request with vlc_preparser_Cancel()
- * @return VLC_PREPARSER_REQ_ID_INVALID in case of error, or a valid id if the
+ * @return NULL in case of error, or a valid request handle if the
  * item was scheduled for preparsing. If this returns an
  * error, the on_preparse_ended will *not* be invoked
  */
-VLC_API vlc_preparser_req_id
+VLC_API vlc_preparser_req *
 vlc_preparser_Push( vlc_preparser_t *preparser, input_item_t *item, int type_option,
                     const input_item_parser_cbs_t *cbs, void *cbs_userdata );
 
@@ -286,14 +292,14 @@ vlc_preparser_Push( vlc_preparser_t *preparser, input_item_t *item, int type_opt
  * @param arg pointer to the arg struct, NULL for default options
  * @param cbs callback to listen to events (can't be NULL)
  * @param cbs_userdata opaque pointer used by the callbacks
- * @return VLC_PREPARSER_REQ_ID_INVALID in case of error, or a valid id if the
+ * @return NULL in case of error, or a valid request handle if the
  * item was scheduled for thumbnailing. If this returns an
  * error, the thumbnailer.on_ended callback will *not* be invoked
  *
  * The provided input_item will be held by the thumbnailer and can safely be
  * released safely after calling this function.
  */
-VLC_API vlc_preparser_req_id
+VLC_API vlc_preparser_req *
 vlc_preparser_GenerateThumbnail( vlc_preparser_t *preparser, input_item_t *item,
                                  const struct vlc_thumbnailer_arg *arg,
                                  const struct vlc_thumbnailer_cbs *cbs,
@@ -332,14 +338,14 @@ vlc_preparser_CheckThumbnailerFormat(enum vlc_thumbnailer_format format);
  * @param output_count outputs array size, must be > 1
  * @param cbs callback to listen to events (can't be NULL)
  * @param cbs_userdata opaque pointer used by the callbacks
- * @return VLC_PREPARSER_REQ_ID_INVALID in case of error, or a valid id if the
+ * @return NULL in case of error, or a valid request handle if the
  * item was scheduled for thumbnailing. If this returns an
  * error, the thumbnailer.on_ended callback will *not* be invoked
  *
  * The provided input_item will be held by the thumbnailer and can safely be
  * released safely after calling this function.
  */
-VLC_API vlc_preparser_req_id
+VLC_API vlc_preparser_req *
 vlc_preparser_GenerateThumbnailToFiles( vlc_preparser_t *preparser, input_item_t *item,
                                         const struct vlc_thumbnailer_arg *arg,
                                         const struct vlc_thumbnailer_output *outputs,
@@ -348,15 +354,24 @@ vlc_preparser_GenerateThumbnailToFiles( vlc_preparser_t *preparser, input_item_t
                                         void *cbs_userdata );
 
 /**
- * This function cancel all preparsing requests for a given id
+ * This function cancels ongoing or queued preparsing/thumbnail generation
+ * for a given request handle.
  *
  * @param preparser the preparser object
- * @param id unique id returned by vlc_preparser_Push(),
- * VLC_PREPARSER_REQ_ID_INVALID to cancels all tasks
+ * @param req request handle returned by vlc_preparser_Push(),
+ * vlc_preparser_GenerateThumbnail(), or vlc_preparser_GenerateThumbnailToFiles().
+ * Pass NULL to cancel all pending and running tasks.
  * @return number of tasks cancelled
+ *
+ * @note
+ * - When a request is cancelled, the `on_ended` callback will be triggered
+ *   with -EINTR status.
+ *
+ * - If the request is already in a terminated state (finished, cancelled, or error),
+ *   the call is a no-op and no callback will be invoked.
  */
 VLC_API size_t vlc_preparser_Cancel( vlc_preparser_t *preparser,
-                                     vlc_preparser_req_id id );
+                                     vlc_preparser_req *req );
 
 /**
  * This function destroys the preparser object and thread.
@@ -375,4 +390,3 @@ VLC_API void vlc_preparser_SetTimeout( vlc_preparser_t *preparser,
 /** @} vlc_preparser */
 
 #endif
-

lib/media.c

@@ -329,6 +329,7 @@ static void input_item_preparse_ended(input_item_t *item,
             vlc_assert_unreachable();
     }
     send_parsed_changed( p_md, new_status );
+    p_md->req = NULL;
 
     if (atomic_fetch_sub_explicit(&p_md->worker_count, 1,
                                   memory_order_release) == 1)
@@ -374,7 +375,7 @@ libvlc_media_t * libvlc_media_new_from_input_item(input_item_t *p_input_item )
 
     p_md->p_input_item->libvlc_owner = p_md;
     atomic_init(&p_md->parsed_status, libvlc_media_parsed_status_none);
-    p_md->id = VLC_PREPARSER_REQ_ID_INVALID;
+    p_md->req = NULL;
 
     libvlc_event_manager_init( &p_md->event_manager, p_md );
 
@@ -818,9 +819,9 @@ int libvlc_media_parse_request(libvlc_instance_t *inst, libvlc_media_t *media,
 
     vlc_preparser_SetTimeout(parser, VLC_TICK_FROM_MS(timeout));
 
-    media->id = vlc_preparser_Push(parser, item, parse_scope,
-                             &preparser_callbacks, media);
-    if (media->id == VLC_PREPARSER_REQ_ID_INVALID)
+    media->req = vlc_preparser_Push(parser, item, parse_scope,
+                                    &preparser_callbacks, media);
+    if (media->req == NULL)
     {
         atomic_fetch_sub_explicit(&media->worker_count, 1,
                                   memory_order_relaxed);
@@ -835,10 +836,10 @@ libvlc_media_parse_stop(libvlc_instance_t *inst, libvlc_media_t *media)
 {
     vlc_preparser_t *parser = libvlc_get_preparser(inst);
     assert(parser != NULL);
-    if (media->id != VLC_PREPARSER_REQ_ID_INVALID)
+    if (media->req != NULL)
     {
-        vlc_preparser_Cancel(parser, media->id);
-        media->id = VLC_PREPARSER_REQ_ID_INVALID;
+        vlc_preparser_Cancel(parser, media->req);
+        media->req = NULL;
     }
 }
 
@@ -927,7 +928,7 @@ struct libvlc_media_thumbnail_request_t
     unsigned int height;
     bool crop;
     libvlc_picture_type_t type;
-    vlc_preparser_req_id id;
+    vlc_preparser_req *preparser_req;
 };
 
 static void media_on_thumbnail_ready( input_item_t *item, int status,
@@ -982,9 +983,9 @@ libvlc_media_thumbnail_request( libvlc_instance_t *inst,
     static const struct vlc_thumbnailer_cbs cbs = {
         .on_ended = media_on_thumbnail_ready,
     };
-    req->id = vlc_preparser_GenerateThumbnail( thumb, md->p_input_item, thumb_arg,
-                                               &cbs, req );
-    if ( req->id == VLC_PREPARSER_REQ_ID_INVALID )
+    req->preparser_req = vlc_preparser_GenerateThumbnail( thumb, md->p_input_item,
+                                                          thumb_arg, &cbs, req );
+    if ( req->preparser_req == NULL )
     {
         free( req );
         libvlc_media_release( md );
@@ -1043,7 +1044,7 @@ void libvlc_media_thumbnail_request_destroy( libvlc_media_thumbnail_request_t *r
     vlc_preparser_t *thumb = libvlc_get_thumbnailer(req->instance);
     assert(thumb != NULL);
 
-    vlc_preparser_Cancel( thumb, req->id );
+    vlc_preparser_Cancel( thumb, req->preparser_req );
     libvlc_media_release( req->md );
     libvlc_release(req->instance);
     free( req );

lib/media_internal.h

@@ -49,7 +49,7 @@ struct libvlc_media_t
     atomic_uint worker_count;
 
     _Atomic libvlc_media_parsed_status_t parsed_status;
-    vlc_preparser_req_id id;
+    vlc_preparser_req *req;
 };
 
 /* Media Descriptor */

modules/gui/qt/network/networkmediamodel.cpp

@@ -94,7 +94,7 @@ class NetworkMediaModelPrivate
 public:
     NetworkMediaModelPrivate(NetworkMediaModel* pub)
         : LocalListBaseModelPrivate<NetworkMediaItemPtr>(pub)
-        , m_preparseSem(1), m_parserId(VLC_PREPARSER_REQ_ID_INVALID)
+        , m_preparseSem(1), m_parserReq(NULL)
     {}
 
 public:
@@ -409,8 +409,8 @@ public:
             std::vector<SharedInputItem> itemList;
             {
                 MediaTreeLocker lock{tree};
-                if (m_parserId != VLC_PREPARSER_REQ_ID_INVALID)
-                    vlc_preparser_Cancel( parser, m_parserId );
+                if (m_parserReq != NULL)
+                    vlc_preparser_Cancel( parser, m_parserReq );
                 m_path = {QVariant::fromValue(PathNode(m_treeItem, m_name))};
                 if (vlc_media_tree_Find( tree.get(), m_treeItem.media.get(), &mediaNode, &parent))
                 {
@@ -438,7 +438,7 @@ public:
         }
 
         m_preparseSem.acquire();
-        m_parserId = vlc_media_tree_Preparse( tree.get(), parser, m_treeItem.media.get() );
+        m_parserReq = vlc_media_tree_Preparse( tree.get(), parser, m_treeItem.media.get() );
 
         m_listener = std::move( l );
 
@@ -481,7 +481,7 @@ public:
 
     struct ListenerCb;
 private:
-    vlc_preparser_req_id m_parserId;
+    vlc_preparser_req *m_parserReq;
 };
 
 // NetworkMediaModel::ListenerCb implementation
@@ -513,10 +513,10 @@ NetworkMediaModel::~NetworkMediaModel()
         auto parser = d->m_ctx->getNetworkPreparser();
         if (likely(parser != NULL))
         {
-            if (d->m_parserId != VLC_PREPARSER_REQ_ID_INVALID)
+            if (d->m_parserReq != NULL)
             {
-                vlc_preparser_Cancel( parser, d->m_parserId );
-                d->m_parserId = VLC_PREPARSER_REQ_ID_INVALID;
+                vlc_preparser_Cancel( parser, d->m_parserReq );
+                d->m_parserReq = NULL;
             }
             //wait for the callback call on cancel
             d->m_preparseSem.acquire();

modules/misc/medialibrary/Thumbnailer.cpp

@@ -110,14 +110,14 @@ bool Thumbnailer::generate( const medialibrary::IMedia&, const std::string& mrl,
             .on_ended = onThumbnailToFilesComplete,
         };
 
-        vlc_preparser_req_id requestId;
-        requestId = vlc_preparser_GenerateThumbnailToFiles(m_thumbnailer.get(),
-                                                           item.get(),
-                                                           &thumb_arg,
-                                                           &thumb_out, 1,
-                                                           &cbs, &ctx);
-
-        if (requestId == VLC_PREPARSER_REQ_ID_INVALID)
+        vlc_preparser_req *preparserReq;
+        preparserReq = vlc_preparser_GenerateThumbnailToFiles(m_thumbnailer.get(),
+                                                              item.get(),
+                                                              &thumb_arg,
+                                                              &thumb_out, 1,
+                                                              &cbs, &ctx);
+
+        if (preparserReq == NULL)
         {
             m_currentContext = nullptr;
             return false;
@@ -132,7 +132,7 @@ bool Thumbnailer::generate( const medialibrary::IMedia&, const std::string& mrl,
 
 void Thumbnailer::stop()
 {
-    vlc_preparser_Cancel(m_thumbnailer.get(), VLC_PREPARSER_REQ_ID_INVALID);
+    vlc_preparser_Cancel(m_thumbnailer.get(), NULL);
 
     vlc::threads::mutex_locker lock{ m_mutex };
     if ( m_currentContext != nullptr )

modules/misc/medialibrary/medialibrary.h

@@ -124,7 +124,7 @@ class Thumbnailer : public medialibrary::IThumbnailer
         Thumbnailer* thumbnailer;
         bool done;
         bool error;
-        vlc_preparser_req_id id;
+        vlc_preparser_req *req;
     };
 public:
     Thumbnailer(vlc_medialibrary_module_t* ml);

src/media_source/media_tree.c

@@ -327,7 +327,7 @@ static const input_item_parser_cbs_t preparser_callbacks = {
     .on_subtree_added = media_subtree_changed,
 };
 
-vlc_preparser_req_id
+vlc_preparser_req *
 vlc_media_tree_Preparse(vlc_media_tree_t *tree, vlc_preparser_t *parser,
                         input_item_t *media)
 {
@@ -336,7 +336,7 @@ vlc_media_tree_Preparse(vlc_media_tree_t *tree, vlc_preparser_t *parser,
     VLC_UNUSED(parser);
     VLC_UNUSED(media);
     VLC_UNUSED(preparser_callbacks);
-    return VLC_PREPARSER_REQ_ID_INVALID;
+    return NULL;
 #else
     return vlc_preparser_Push(parser, media, VLC_PREPARSER_TYPE_PARSE |
                               VLC_PREPARSER_OPTION_INTERACT |

src/playlist/content.c

@@ -80,8 +80,8 @@ vlc_playlist_ItemsInserted(vlc_playlist_t *playlist, size_t index, size_t count,
     for (size_t i = index; i < index + count; ++i)
     {
         vlc_playlist_item_t *item = playlist->items.data[i];
-        item->preparser_id = vlc_playlist_AutoPreparse(playlist, item->media,
-                                                       subitems);
+        item->preparser_req = vlc_playlist_AutoPreparse(playlist, item->media,
+                                                        subitems);
     }
 }
 
@@ -238,7 +238,7 @@ vlc_playlist_Clear(vlc_playlist_t *playlist)
     VLC_UNUSED(ret); /* what could we do? */
 
     if (playlist->parser != NULL)
-        vlc_preparser_Cancel(playlist->parser, VLC_PREPARSER_REQ_ID_INVALID);
+        vlc_preparser_Cancel(playlist->parser, NULL);
 
     vlc_playlist_ClearItems(playlist);
     vlc_playlist_ItemsReset(playlist);
@@ -319,8 +319,8 @@ vlc_playlist_Remove(vlc_playlist_t *playlist, size_t index, size_t count)
     for (size_t i = 0; i < count; ++i) {
         vlc_playlist_item_t *item = playlist->items.data[index + i];
         if (playlist->parser != NULL
-                && item->preparser_id != VLC_PREPARSER_REQ_ID_INVALID)
-            vlc_preparser_Cancel(playlist->parser, item->preparser_id);
+                && item->preparser_req != NULL)
+            vlc_preparser_Cancel(playlist->parser, item->preparser_req);
 
         vlc_playlist_item_Release(item);
     }
@@ -356,8 +356,8 @@ vlc_playlist_Replace(vlc_playlist_t *playlist, size_t index,
 
     vlc_playlist_item_t *old = playlist->items.data[index];
     if (playlist->parser != NULL
-            && old->preparser_id != VLC_PREPARSER_REQ_ID_INVALID)
-        vlc_preparser_Cancel(playlist->parser, old->preparser_id);
+            && old->preparser_req != NULL)
+        vlc_preparser_Cancel(playlist->parser, old->preparser_req);
     vlc_playlist_item_Release(old);
     playlist->items.data[index] = item;
 

src/playlist/item.c

@@ -36,7 +36,7 @@ vlc_playlist_item_New(input_item_t *media, uint64_t id)
 
     vlc_atomic_rc_init(&item->rc);
     item->id = id;
-    item->preparser_id = VLC_PREPARSER_REQ_ID_INVALID;
+    item->preparser_req = NULL;
     item->media = media;
     input_item_Hold(media);
     return item;

src/playlist/item.h

@@ -31,7 +31,7 @@ struct vlc_playlist_item
 {
     input_item_t *media;
     uint64_t id;
-    vlc_preparser_req_id preparser_id;
+    vlc_preparser_req *preparser_req;
     vlc_atomic_rc_t rc;
 };
 

src/playlist/preparse.c

@@ -110,7 +110,7 @@ static const input_item_parser_cbs_t preparser_callbacks = {
     .on_subtree_added = on_subtree_added,
 };
 
-vlc_preparser_req_id
+vlc_preparser_req *
 vlc_playlist_AutoPreparse(vlc_playlist_t *playlist, input_item_t *input,
                           bool parse_subitems)
 {
@@ -137,7 +137,7 @@ vlc_playlist_AutoPreparse(vlc_playlist_t *playlist, input_item_t *input,
         enum input_item_type_e input_type = input_item_GetType(input, &input_net);
 
         if (input_net)
-            return VLC_PREPARSER_REQ_ID_INVALID;
+            return NULL;
 
         switch (input_type)
         {
@@ -147,7 +147,7 @@ vlc_playlist_AutoPreparse(vlc_playlist_t *playlist, input_item_t *input,
             case ITEM_TYPE_PLAYLIST:
                 break;
             default:
-                return VLC_PREPARSER_REQ_ID_INVALID;
+                return NULL;
         }
 
         int options = VLC_PREPARSER_TYPE_PARSE | VLC_PREPARSER_TYPE_FETCHMETA_LOCAL;
@@ -157,5 +157,5 @@ vlc_playlist_AutoPreparse(vlc_playlist_t *playlist, input_item_t *input,
         return vlc_preparser_Push(playlist->parser, input, options,
                                   &preparser_callbacks, playlist);
     }
-    return VLC_PREPARSER_REQ_ID_INVALID;
+    return NULL;
 }

src/playlist/preparse.h

@@ -27,7 +27,7 @@
 typedef struct vlc_playlist vlc_playlist_t;
 typedef struct input_item_node_t input_item_node_t;
 
-vlc_preparser_req_id
+vlc_preparser_req *
 vlc_playlist_AutoPreparse(vlc_playlist_t *playlist, input_item_t *input,
                           bool parse_subitems);
 

src/preparser/preparser.c

@@ -53,7 +53,6 @@ struct vlc_preparser_t
     vlc_tick_t timeout;
 
     vlc_mutex_t lock;
-    vlc_preparser_req_id current_id;
     struct vlc_list submitted_tasks; /**< list of struct task */
 };
 
@@ -75,7 +74,6 @@ struct vlc_preparser_req
     struct vlc_thumbnailer_arg thumb_arg;
     union vlc_preparser_cbs_internal cbs;
     void *userdata;
-    vlc_preparser_req_id id;
 
     vlc_interrupt_t *i11e_ctx;
     picture_t *pic;
@@ -145,24 +143,12 @@ PreparserRequestDelete(struct vlc_preparser_req *req)
     free(req);
 }
 
-static vlc_preparser_req_id
-PreparserGetNextTaskIdLocked(vlc_preparser_t *preparser, struct vlc_preparser_req *req)
-{
-    vlc_preparser_req_id id = req->id = preparser->current_id++;
-    static_assert(VLC_PREPARSER_REQ_ID_INVALID == 0, "Invalid id should be 0");
-    if (unlikely(preparser->current_id == 0)) /* unsigned wrapping */
-        ++preparser->current_id;
-    return id;
-}
-
-static vlc_preparser_req_id
+static void
 PreparserAddTask(vlc_preparser_t *preparser, struct vlc_preparser_req *req)
 {
     vlc_mutex_lock(&preparser->lock);
-    vlc_preparser_req_id id = PreparserGetNextTaskIdLocked(preparser, req);
     vlc_list_append(&req->node, &preparser->submitted_tasks);
     vlc_mutex_unlock(&preparser->lock);
-    return id;
 }
 
 static void
@@ -633,7 +619,6 @@ vlc_preparser_t* vlc_preparser_New( vlc_object_t *parent,
 
     vlc_mutex_init(&preparser->lock);
     vlc_list_init(&preparser->submitted_tasks);
-    preparser->current_id = 1;
 
     return preparser;
 
@@ -651,10 +636,11 @@ error_parser:
     return NULL;
 }
 
-vlc_preparser_req_id vlc_preparser_Push( vlc_preparser_t *preparser, input_item_t *item,
-                                         int type_options,
-                                         const input_item_parser_cbs_t *cbs,
-                                         void *cbs_userdata )
+vlc_preparser_req *
+vlc_preparser_Push( vlc_preparser_t *preparser, input_item_t *item,
+                    int type_options,
+                    const input_item_parser_cbs_t *cbs,
+                    void *cbs_userdata )
 {
     assert((type_options & VLC_PREPARSER_TYPE_THUMBNAIL) == 0);
     assert((type_options & VLC_PREPARSER_TYPE_THUMBNAIL_TO_FILES) == 0);
@@ -676,28 +662,22 @@ vlc_preparser_req_id vlc_preparser_Push( vlc_preparser_t *preparser, input_item_
     struct vlc_preparser_req *req = PreparserRequestNew(preparser, ParserRun, item, type_options,
                                                         NULL, req_cbs, cbs_userdata);
     if( !req )
-        return VLC_PREPARSER_REQ_ID_INVALID;
+        return NULL;
 
     if (preparser->parser != NULL)
     {
-        vlc_preparser_req_id id = PreparserAddTask(preparser, req);
+        PreparserAddTask(preparser, req);
 
         vlc_executor_Submit(preparser->parser, &req->runnable);
 
-        return id;
+        return req;
     }
 
-    /* input_fetcher is not cancellable (for now) but we need to generate a new
-     * id anyway. */
-    vlc_mutex_lock(&preparser->lock);
-    vlc_preparser_req_id id = PreparserGetNextTaskIdLocked(preparser, req);
-    vlc_mutex_unlock(&preparser->lock);
-
     int ret = Fetch(req);
-    return ret == VLC_SUCCESS ? id : 0;
+    return ret == VLC_SUCCESS ? req : NULL;
 }
 
-vlc_preparser_req_id
+vlc_preparser_req *
 vlc_preparser_GenerateThumbnail( vlc_preparser_t *preparser, input_item_t *item,
                                  const struct vlc_thumbnailer_arg *thumb_arg,
                                  const struct vlc_thumbnailer_cbs *cbs,
@@ -714,13 +694,13 @@ vlc_preparser_GenerateThumbnail( vlc_preparser_t *preparser, input_item_t *item,
         PreparserRequestNew(preparser, ThumbnailerRun, item, VLC_PREPARSER_TYPE_THUMBNAIL,
                             thumb_arg, req_cbs, cbs_userdata);
     if (req == NULL)
-        return VLC_PREPARSER_REQ_ID_INVALID;
+        return NULL;
 
-    vlc_preparser_req_id id = PreparserAddTask(preparser, req);
+    PreparserAddTask(preparser, req);
 
     vlc_executor_Submit(preparser->thumbnailer, &req->runnable);
 
-    return id;
+    return req;
 }
 
 static int
@@ -785,7 +765,7 @@ vlc_preparser_CheckThumbnailerFormat(enum vlc_thumbnailer_format format)
     return CheckThumbnailerFormat(format, NULL, NULL, NULL);
 }
 
-vlc_preparser_req_id
+vlc_preparser_req *
 vlc_preparser_GenerateThumbnailToFiles( vlc_preparser_t *preparser, input_item_t *item,
                                         const struct vlc_thumbnailer_arg *thumb_arg,
                                         const struct vlc_thumbnailer_output *outputs,
@@ -806,13 +786,13 @@ vlc_preparser_GenerateThumbnailToFiles( vlc_preparser_t *preparser, input_item_t
                             VLC_PREPARSER_TYPE_THUMBNAIL_TO_FILES, thumb_arg,
                             req_cbs, cbs_userdata);
     if (req == NULL)
-        return VLC_PREPARSER_REQ_ID_INVALID;
+        return NULL;
 
     req->outputs = vlc_alloc(output_count, sizeof(*outputs));
     if (unlikely(req->outputs == NULL))
     {
         PreparserRequestDelete(req);
-        return VLC_PREPARSER_REQ_ID_INVALID;
+        return NULL;
     }
 
     size_t valid_output_count = 0;
@@ -838,7 +818,7 @@ vlc_preparser_GenerateThumbnailToFiles( vlc_preparser_t *preparser, input_item_t
         if (unlikely(dst->file_path == NULL))
         {
             PreparserRequestDelete(req);
-            return VLC_PREPARSER_REQ_ID_INVALID;
+            return NULL;
         }
         req->output_count++;
     }
@@ -847,17 +827,17 @@ vlc_preparser_GenerateThumbnailToFiles( vlc_preparser_t *preparser, input_item_t
     {
         PreparserRequestDelete(req);
         msg_Err(preparser->owner, "thumbnailer: no valid \"image encoder\" found");
-        return VLC_PREPARSER_REQ_ID_INVALID;
+        return NULL;
     }
 
-    vlc_preparser_req_id id = PreparserAddTask(preparser, req);
+    PreparserAddTask(preparser, req);
 
     vlc_executor_Submit(preparser->thumbnailer, &req->runnable);
 
-    return id;
+    return req;
 }
 
-size_t vlc_preparser_Cancel( vlc_preparser_t *preparser, vlc_preparser_req_id id )
+size_t vlc_preparser_Cancel( vlc_preparser_t *preparser, vlc_preparser_req *req )
 {
     vlc_mutex_lock(&preparser->lock);
 
@@ -865,7 +845,7 @@ size_t vlc_preparser_Cancel( vlc_preparser_t *preparser, vlc_preparser_req_id id
     size_t count = 0;
     vlc_list_foreach(req_itr, &preparser->submitted_tasks, node)
     {
-        if (id == VLC_PREPARSER_REQ_ID_INVALID || req_itr->id == id)
+        if (req == NULL || req_itr == req)
         {
             count++;
 
@@ -924,7 +904,7 @@ size_t vlc_preparser_Cancel( vlc_preparser_t *preparser, vlc_preparser_req_id id
 
                 /* Small optimisation in the likely case where the user cancel
                  * only one task */
-                if (id != VLC_PREPARSER_REQ_ID_INVALID)
+                if (req != NULL)
                     return count;
                 vlc_mutex_lock(&preparser->lock);
             }
@@ -948,7 +928,7 @@ void vlc_preparser_SetTimeout( vlc_preparser_t *preparser,
 void vlc_preparser_Delete( vlc_preparser_t *preparser )
 {
     /* In case vlc_preparser_Deactivate() has not been called */
-    vlc_preparser_Cancel(preparser, 0);
+    vlc_preparser_Cancel(preparser, NULL);
 
     if (preparser->parser != NULL)
         vlc_executor_Delete(preparser->parser);

test/libvlc/media.c

@@ -261,13 +261,13 @@ static void test_input_metadata_timeout(libvlc_instance_t *vlc, int timeout,
     vlc_preparser_t *parser = vlc_preparser_New(VLC_OBJECT(vlc->p_libvlc_int),
                                                 &cfg);
     assert(parser != NULL);
-    vlc_preparser_req_id id = vlc_preparser_Push(parser, p_item, options, &cbs, &sem);
-    assert(id != VLC_PREPARSER_REQ_ID_INVALID);
+    vlc_preparser_req *req = vlc_preparser_Push(parser, p_item, options, &cbs, &sem);
+    assert(req != NULL);
 
     if (wait_and_cancel > 0)
     {
         vlc_tick_sleep( VLC_TICK_FROM_MS(wait_and_cancel) );
-        size_t count = vlc_preparser_Cancel(parser, id);
+        size_t count = vlc_preparser_Cancel(parser, req);
         assert(count == 1);
     }
     vlc_sem_wait(&sem);

test/src/preparser/thumbnail.c

@@ -150,7 +150,7 @@ static void test_thumbnails( libvlc_instance_t* p_vlc )
 
         vlc_mutex_lock( &ctx.lock );
 
-        vlc_preparser_req_id id;
+        vlc_preparser_req *req;
         struct vlc_thumbnailer_arg thumb_arg;
         if ( test_params[i].b_use_pos )
         {
@@ -170,9 +170,9 @@ static void test_thumbnails( libvlc_instance_t* p_vlc )
         static const struct vlc_thumbnailer_cbs cbs = {
             .on_ended = thumbnailer_callback,
         };
-        id = vlc_preparser_GenerateThumbnail( p_thumbnailer, p_item, &thumb_arg,
-                                              &cbs, &ctx );
-        assert( id != VLC_PREPARSER_REQ_ID_INVALID );
+        req = vlc_preparser_GenerateThumbnail( p_thumbnailer, p_item, &thumb_arg,
+                                               &cbs, &ctx );
+        assert( req != NULL );
 
         while ( ctx.b_done == false )
             vlc_cond_wait( &ctx.cond, &ctx.lock );
@@ -220,10 +220,10 @@ static void test_cancel_thumbnail( libvlc_instance_t* p_vlc )
 
     vlc_sem_t sem;
     vlc_sem_init(&sem, 0);
-    vlc_preparser_req_id id =
+    vlc_preparser_req *req =
         vlc_preparser_GenerateThumbnail( p_thumbnailer, p_item, NULL, &cbs, &sem );
 
-    vlc_preparser_Cancel( p_thumbnailer, id );
+    vlc_preparser_Cancel( p_thumbnailer, req );
 
     vlc_sem_wait(&sem);
 

test/src/preparser/thumbnail_to_files.c

@@ -154,11 +154,11 @@ static void on_ended(input_item_t *item, int status,
                 free(option);
             }
 
-            vlc_preparser_req_id req_id =
+            vlc_preparser_req *req =
                 vlc_preparser_Push(context->preparser, thumb,
                                    VLC_PREPARSER_TYPE_PARSE,
                                    &parser_cbs, context);
-            assert(req_id != VLC_PREPARSER_REQ_ID_INVALID);
+            assert(req != NULL);
             input_item_Release(thumb);
         }
     }
@@ -329,18 +329,18 @@ int main(int argc, const char *argv[])
     input_item_t *item = input_item_New(MOCK_URL, "mock");
     assert(item != NULL);
 
-    vlc_preparser_req_id req_id =
+    vlc_preparser_req *req =
         vlc_preparser_GenerateThumbnailToFiles(preparser, item, &arg,
                                                entries, test_count,
                                                &cbs, &context);
 
-    assert(req_id != VLC_PREPARSER_REQ_ID_INVALID);
+    assert(req != NULL);
 
     /* Wait for all tests */
     for (size_t i = 0; i < test_count; ++i)
         vlc_sem_wait(&context.sem);
 
-    size_t count = vlc_preparser_Cancel(preparser, req_id);
+    size_t count = vlc_preparser_Cancel(preparser, req);
     assert(count == 0); /* Should not be cancelled and already processed */
 
     for (size_t i = 0; i < test_count; ++i)