shared: Do not print deprecations when compiling own code

We keep and use old functions in code for the compatibility reasons with
older API versions. Do not print warnings about them being deprecated when
compiling Clapper library that has and uses such function internally.

meson.build

@@ -11,7 +11,7 @@ project('clapper', 'c',
 glib_req = '>= 2.76.0'
 gst_req = '>= 1.24.0'
 gtk4_req = '>= 4.10.0'
-adw_req = '>= 1.4.0'
+adw_req = '>= 1.5.0'
 
 clapper_version = meson.project_version().split('-')[0]
 version_array = clapper_version.split('.')

src/bin/clapper-app/data/meson.build

@@ -1,10 +1,11 @@
-appstream_util = find_program('appstream-util', required: false)
-if appstream_util.found()
+appstream_cli = find_program('appstreamcli', required: false)
+if appstream_cli.found()
   test('Validate appstream file',
-    appstream_util,
+    appstream_cli,
     args: [
-      'validate-relax',
-      '--nonet',
+      'validate',
+      '--no-net',
+      '--explain',
       join_paths(meson.current_source_dir(), 'metainfo', 'com.github.rafostar.Clapper.metainfo.xml'),
     ]
   )

src/lib/clapper-gtk/meson.build

@@ -176,7 +176,6 @@ if build_gir
       clappergtk_enums,
     ],
     extra_args: [
-      gir_init_section,
       '--quiet',
       '--warn-all',
       '-DCLAPPER_GTK_COMPILATION',

src/lib/clapper/clapper-cache-private.h

@@ -27,6 +27,9 @@ G_BEGIN_DECLS
 G_GNUC_INTERNAL
 void clapper_cache_initialize (void);
 
+G_GNUC_INTERNAL
+gboolean clapper_cache_is_disabled (void);
+
 G_GNUC_INTERNAL
 GMappedFile * clapper_cache_open (const gchar *filename, const gchar **data, GError **error);
 
@@ -39,12 +42,18 @@ gint clapper_cache_read_int (const gchar **data);
 G_GNUC_INTERNAL
 guint clapper_cache_read_uint (const gchar **data);
 
+G_GNUC_INTERNAL
+gint64 clapper_cache_read_int64 (const gchar **data);
+
 G_GNUC_INTERNAL
 gdouble clapper_cache_read_double (const gchar **data);
 
 G_GNUC_INTERNAL
 const gchar * clapper_cache_read_string (const gchar **data);
 
+G_GNUC_INTERNAL
+const guint8 * clapper_cache_read_data (const gchar **data, gsize *size);
+
 G_GNUC_INTERNAL
 GType clapper_cache_read_enum (const gchar **data);
 
@@ -69,12 +78,18 @@ void clapper_cache_store_int (GByteArray *bytes, gint val);
 G_GNUC_INTERNAL
 void clapper_cache_store_uint (GByteArray *bytes, guint val);
 
+G_GNUC_INTERNAL
+void clapper_cache_store_int64 (GByteArray *bytes, gint64 val);
+
 G_GNUC_INTERNAL
 void clapper_cache_store_double (GByteArray *bytes, gdouble val);
 
 G_GNUC_INTERNAL
 void clapper_cache_store_string (GByteArray *bytes, const gchar *val);
 
+G_GNUC_INTERNAL
+void clapper_cache_store_data (GByteArray *bytes, const guint8 *val, gsize val_size);
+
 G_GNUC_INTERNAL
 void clapper_cache_store_enum (GByteArray *bytes, GType enum_type);
 

src/lib/clapper/clapper-cache.c

@@ -45,6 +45,12 @@ clapper_cache_initialize (void)
   }
 }
 
+gboolean
+clapper_cache_is_disabled (void)
+{
+  return cache_disabled;
+}
+
 GMappedFile *
 clapper_cache_open (const gchar *filename, const gchar **data, GError **error)
 {
@@ -111,6 +117,15 @@ clapper_cache_read_uint (const gchar **data)
   return val;
 }
 
+inline gint64
+clapper_cache_read_int64 (const gchar **data)
+{
+  gint64 val = *(const gint64 *) *data;
+  *data += sizeof (gint64);
+
+  return val;
+}
+
 inline gdouble
 clapper_cache_read_double (const gchar **data)
 {
@@ -134,6 +149,22 @@ clapper_cache_read_string (const gchar **data)
   return str;
 }
 
+inline const guint8 *
+clapper_cache_read_data (const gchar **data, gsize *size)
+{
+  const guint8 *val = NULL;
+
+  *size = *(const gsize *) *data;
+  *data += sizeof (gsize);
+
+  if (G_LIKELY (*size > 0)) {
+    val = (const guint8 *) *data;
+    *data += *size;
+  }
+
+  return val;
+}
+
 inline GType
 clapper_cache_read_enum (const gchar **data)
 {
@@ -332,6 +363,12 @@ clapper_cache_store_uint (GByteArray *bytes, guint val)
   g_byte_array_append (bytes, (const guint8 *) &val, sizeof (guint));
 }
 
+inline void
+clapper_cache_store_int64 (GByteArray *bytes, gint64 val)
+{
+  g_byte_array_append (bytes, (const guint8 *) &val, sizeof (gint64));
+}
+
 inline void
 clapper_cache_store_double (GByteArray *bytes, gdouble val)
 {
@@ -349,6 +386,14 @@ clapper_cache_store_string (GByteArray *bytes, const gchar *val)
     g_byte_array_append (bytes, (const guint8 *) val, strlen (val) + 1);
 }
 
+inline void
+clapper_cache_store_data (GByteArray *bytes, const guint8 *val, gsize val_size)
+{
+  g_byte_array_append (bytes, (const guint8 *) &val_size, sizeof (gsize));
+  if (G_LIKELY (val_size > 0))
+    g_byte_array_append (bytes, val, val_size);
+}
+
 inline void
 clapper_cache_store_enum (GByteArray *bytes, GType enum_type)
 {

src/lib/clapper/clapper-enhancer-proxy-private.h

@@ -21,6 +21,7 @@
 
 #include <glib.h>
 #include <glib-object.h>
+#include <gst/gst.h>
 
 #include "clapper-enhancer-proxy.h"
 
@@ -45,6 +46,9 @@ G_GNUC_INTERNAL
 GObject * clapper_enhancer_proxy_get_peas_info (ClapperEnhancerProxy *proxy);
 
 G_GNUC_INTERNAL
-void clapper_enhancer_proxy_apply_current_config_to_enhancer (ClapperEnhancerProxy *proxy, GObject *enhancer);
+GstStructure * clapper_enhancer_proxy_make_current_config (ClapperEnhancerProxy *proxy);
+
+G_GNUC_INTERNAL
+void clapper_enhancer_proxy_apply_config_to_enhancer (ClapperEnhancerProxy *proxy, const GstStructure *config, GObject *enhancer);
 
 G_END_DECLS

src/lib/clapper/clapper-enhancer-proxy.c

@@ -213,7 +213,7 @@ clapper_enhancer_proxy_copy (ClapperEnhancerProxy *src_proxy, const gchar *copy_
   copy->pspecs = g_new (GParamSpec *, copy->n_pspecs);
 
   for (i = 0; i < src_proxy->n_pspecs; ++i)
-    copy->pspecs[i] = src_proxy->pspecs[i];
+    copy->pspecs[i] = g_param_spec_ref (src_proxy->pspecs[i]);
 
   copy->scope = CLAPPER_ENHANCER_PARAM_LOCAL;
 
@@ -345,8 +345,10 @@ clapper_enhancer_proxy_fill_from_cache (ClapperEnhancerProxy *self)
   }
 
   /* Plugin version check */
-  if (g_strcmp0 (clapper_cache_read_string (&data), self->version) != 0)
+  if (g_strcmp0 (clapper_cache_read_string (&data), self->version) != 0) {
+    g_mapped_file_unref (mapped_file);
     return FALSE; // not an error
+  }
 
   /* Restore Interfaces */
   if ((self->n_ifaces = clapper_cache_read_uint (&data)) > 0) {
@@ -505,15 +507,18 @@ _apply_config_cb (GQuark field_id, const GValue *value, GObject *enhancer)
   return TRUE;
 }
 
-void
-clapper_enhancer_proxy_apply_current_config_to_enhancer (ClapperEnhancerProxy *self, GObject *enhancer)
+/*
+ * clapper_enhancer_proxy_make_current_config:
+ *
+ * Returns: (transfer full) (nullable): Current merged global and local config as #GstStructure.
+ */
+GstStructure *
+clapper_enhancer_proxy_make_current_config (ClapperEnhancerProxy *self)
 {
   GSettings *settings = clapper_enhancer_proxy_get_settings (self);
   GstStructure *merged_config = NULL;
   guint i;
 
-  GST_DEBUG_OBJECT (self, "Applying config to enhancer");
-
   /* Lock here to ensure consistent local config */
   GST_OBJECT_LOCK (self);
 
@@ -585,13 +590,14 @@ clapper_enhancer_proxy_apply_current_config_to_enhancer (ClapperEnhancerProxy *s
 
   g_clear_object (&settings);
 
-  /* Nothing if no configurable properties
-   * or all have default values */
-  if (merged_config) {
-    gst_structure_foreach (merged_config, (GstStructureForeachFunc) _apply_config_cb, enhancer);
-    gst_structure_free (merged_config);
-  }
+  return merged_config;
+}
 
+void
+clapper_enhancer_proxy_apply_config_to_enhancer (ClapperEnhancerProxy *self, const GstStructure *config, GObject *enhancer)
+{
+  GST_DEBUG_OBJECT (self, "Applying config to enhancer");
+  gst_structure_foreach (config, (GstStructureForeachFunc) _apply_config_cb, enhancer);
   GST_DEBUG_OBJECT (self, "Enhancer config applied");
 }
 
@@ -700,7 +706,7 @@ clapper_enhancer_proxy_get_version (ClapperEnhancerProxy *self)
  *
  * Get extra data from enhancer plugin info file specified by @key.
  *
- * External data in the plugin info file is prefixed with `X-`.
+ * Extra data in the plugin info file is prefixed with `X-`.
  * For example `X-Schemes=https`.
  *
  * Returns: (nullable): extra data value of the proxied enhancer.
@@ -734,6 +740,10 @@ clapper_enhancer_proxy_get_extra_data (ClapperEnhancerProxy *self, const gchar *
  * calling this function with "X-Schemes" as key and "http" as value will
  * return %TRUE.
  *
+ * It is also safe to call this function when there is no such @key
+ * in plugin info file. Use [method@Clapper.EnhancerProxy.get_extra_data]
+ * if you need to know whether key exists.
+ *
  * Returns: whether list named with @key existed and contained @value.
  *
  * Since: 0.10

src/lib/clapper/clapper-harvest-private.h

@@ -23,6 +23,7 @@
 #include <gst/tag/tag.h>
 
 #include "clapper-harvest.h"
+#include "clapper-enhancer-proxy.h"
 
 G_BEGIN_DECLS
 
@@ -32,4 +33,10 @@ ClapperHarvest * clapper_harvest_new (void);
 G_GNUC_INTERNAL
 gboolean clapper_harvest_unpack (ClapperHarvest *harvest, GstBuffer **buffer, gsize *buf_size, GstCaps **caps, GstTagList **tags, GstToc **toc, GstStructure **headers);
 
+G_GNUC_INTERNAL
+gboolean clapper_harvest_fill_from_cache (ClapperHarvest *harvest, ClapperEnhancerProxy *proxy, const GstStructure *config, GUri *uri);
+
+G_GNUC_INTERNAL
+void clapper_harvest_export_to_cache (ClapperHarvest *harvest, ClapperEnhancerProxy *proxy, const GstStructure *config, GUri *uri);
+
 G_END_DECLS

src/lib/clapper/clapper-harvest.c

@@ -31,7 +31,11 @@
  * https://gitlab.freedesktop.org/gstreamer/gstreamer/-/issues/2867
  */
 
+#include "config.h"
+
 #include "clapper-harvest-private.h"
+#include "clapper-cache-private.h"
+#include "clapper-utils.h"
 
 #define GST_CAT_DEFAULT clapper_harvest_debug
 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
@@ -50,6 +54,8 @@ struct _ClapperHarvest
 
   guint16 n_chapters;
   guint16 n_tracks;
+
+  gint64 exp_epoch;
 };
 
 #define parent_class clapper_harvest_parent_class
@@ -119,6 +125,302 @@ clapper_harvest_unpack (ClapperHarvest *self,
   return TRUE;
 }
 
+/* Custom implementation due to the lack of TOC serialization in GStreamer */
+static void
+_harvest_fill_toc_from_cache (ClapperHarvest *self, const gchar **data)
+{
+  guint i, n_entries;
+
+  n_entries = clapper_cache_read_uint (data);
+  for (i = 0; i < n_entries; ++i) {
+    guint j, n_subentries;
+
+    n_subentries = clapper_cache_read_uint (data);
+    for (j = 0; j < n_subentries; ++j) {
+      GstTocEntryType type;
+      const gchar *title;
+      gdouble start, end;
+
+      type = (GstTocEntryType) clapper_cache_read_int (data);
+      title = clapper_cache_read_string (data);
+      start = clapper_cache_read_double (data);
+      end = clapper_cache_read_double (data);
+
+      clapper_harvest_toc_add (self, type, title, start, end);
+    }
+  }
+}
+
+static void
+_harvest_store_toc_to_cache (ClapperHarvest *self, GByteArray *bytes)
+{
+  GList *list = NULL, *el;
+  guint n_entries = 0;
+
+  if (self->toc) {
+    list = gst_toc_get_entries (self->toc);
+    n_entries = g_list_length (list);
+  }
+  clapper_cache_store_uint (bytes, n_entries);
+
+  for (el = list; el; el = g_list_next (el)) {
+    const GstTocEntry *entry = (const GstTocEntry *) el->data;
+    GList *subentries, *sub_el;
+    guint n_subentries;
+
+    subentries = gst_toc_entry_get_sub_entries (entry);
+    n_subentries = g_list_length (subentries);
+
+    clapper_cache_store_uint (bytes, n_subentries);
+
+    for (sub_el = subentries; sub_el; sub_el = g_list_next (sub_el)) {
+      const GstTocEntry *subentry = (const GstTocEntry *) sub_el->data;
+      GstTagList *tags;
+      gint64 start = 0, end = 0;
+      gdouble start_dbl, end_dbl;
+      const gchar *title = NULL;
+
+      clapper_cache_store_int (bytes, (gint) gst_toc_entry_get_entry_type (subentry));
+
+      if ((tags = gst_toc_entry_get_tags (subentry)))
+        gst_tag_list_peek_string_index (tags, GST_TAG_TITLE, 0, &title);
+
+      clapper_cache_store_string (bytes, title);
+
+      gst_toc_entry_get_start_stop_times (subentry, &start, &end);
+      start_dbl = ((gdouble) start) / GST_SECOND;
+      end_dbl = (end >= 0) ? ((gdouble) end) / GST_SECOND : -1;
+
+      clapper_cache_store_double (bytes, start_dbl);
+      clapper_cache_store_double (bytes, end_dbl);
+    }
+  }
+}
+
+static inline gchar *
+_build_cache_filename (ClapperEnhancerProxy *proxy, GUri *uri)
+{
+  gchar *uri_str = g_uri_to_string (uri);
+  gchar name[15];
+
+  g_snprintf (name, sizeof (name), "%u.bin", g_str_hash (uri_str));
+  g_free (uri_str);
+
+  return g_build_filename (g_get_user_cache_dir (), CLAPPER_API_NAME,
+      "enhancers", clapper_enhancer_proxy_get_module_name (proxy),
+      "harvests", name, NULL);
+}
+
+/* NOTE: On failure, this function must not modify harvest! */
+gboolean
+clapper_harvest_fill_from_cache (ClapperHarvest *self, ClapperEnhancerProxy *proxy,
+    const GstStructure *config, GUri *uri)
+{
+  GMappedFile *mapped_file;
+  GstStructure *config_cached = NULL;
+  GError *error = NULL;
+  gchar *filename;
+  const gchar *data, *read_str;
+  const guint8 *buf_data;
+  guint8 *buf_copy;
+  gsize buf_size;
+  gint64 epoch_cached, epoch_now = 0;
+  gdouble exp_seconds;
+  gboolean changed, read_ok = FALSE;
+
+  filename = _build_cache_filename (proxy, uri);
+  GST_DEBUG_OBJECT (self, "Importing harvest from cache file: \"%s\"", filename);
+  mapped_file = clapper_cache_open (filename, &data, &error);
+  g_free (filename);
+
+  if (!mapped_file) {
+    /* No error if cache disabled or version mismatch */
+    if (error) {
+      if (error->domain == G_FILE_ERROR && error->code == G_FILE_ERROR_NOENT)
+        GST_DEBUG_OBJECT (self, "No cached harvest found");
+      else
+        GST_ERROR_OBJECT (self, "Could not use cached harvest, reason: %s", error->message);
+
+      g_error_free (error);
+    }
+
+    return FALSE;
+  }
+
+  /* Plugin version check */
+  if (g_strcmp0 (clapper_cache_read_string (&data),
+      clapper_enhancer_proxy_get_version (proxy)) != 0)
+    goto finish; // no error printing here
+
+  if (G_LIKELY ((epoch_cached = clapper_cache_read_int64 (&data)) > 0)) {
+    GDateTime *date = g_date_time_new_now_utc ();
+    epoch_now = g_date_time_to_unix (date);
+    g_date_time_unref (date);
+  }
+
+  /* Check if expired */
+  if ((exp_seconds = (gdouble) (epoch_cached - epoch_now)) <= 0) {
+    GST_DEBUG_OBJECT (self, "Cached harvest expired"); // expiration is not an error
+    goto finish;
+  }
+  GST_DEBUG_OBJECT (self, "Cached harvest expiration in %" CLAPPER_TIME_FORMAT,
+      CLAPPER_TIME_ARGS (exp_seconds));
+
+  /* Read last used config to generate cache data */
+  if ((read_str = clapper_cache_read_string (&data)))
+    config_cached = gst_structure_from_string (read_str, NULL);
+
+  /* Compare used config when cache was generated to the current one */
+  changed = (config_cached && config)
+      ? !gst_structure_is_equal (config_cached, config)
+      : (config_cached != config);
+
+  gst_clear_structure (&config_cached);
+
+  if (changed) {
+    GST_DEBUG_OBJECT (self, "Enhancer config differs from the last time");
+    goto finish;
+  }
+
+  /* Read media type */
+  read_str = clapper_cache_read_string (&data);
+  if (G_UNLIKELY (read_str == NULL)) {
+    GST_ERROR_OBJECT (self, "Could not read media type from cache file");
+    goto finish;
+  }
+
+  /* Read buffer data */
+  buf_data = clapper_cache_read_data (&data, &buf_size);
+  if (G_UNLIKELY (buf_data == NULL)) {
+    GST_ERROR_OBJECT (self, "Could not read buffer data from cache");
+    goto finish;
+  }
+
+  /* Fill harvest */
+  buf_copy = g_memdup2 (buf_data, buf_size);
+  if (!clapper_harvest_fill (self, read_str, buf_copy, buf_size))
+    goto finish;
+
+  /* Read tags */
+  read_str = clapper_cache_read_string (&data);
+  if (read_str && (self->tags = gst_tag_list_new_from_string (read_str))) {
+    GST_LOG_OBJECT (self, "Read %s", read_str);
+    gst_tag_list_set_scope (self->tags, GST_TAG_SCOPE_GLOBAL);
+  }
+
+  /* Read TOC */
+  _harvest_fill_toc_from_cache (self, &data);
+
+  /* Read headers */
+  read_str = clapper_cache_read_string (&data);
+  if (read_str && (self->headers = gst_structure_from_string (read_str, NULL)))
+    GST_LOG_OBJECT (self, "Read %s", read_str);
+
+  read_ok = TRUE;
+
+finish:
+  g_mapped_file_unref (mapped_file);
+
+  if (!read_ok)
+    return FALSE;
+
+  GST_DEBUG_OBJECT (self, "Filled harvest from cache");
+  return TRUE;
+}
+
+void
+clapper_harvest_export_to_cache (ClapperHarvest *self, ClapperEnhancerProxy *proxy,
+    const GstStructure *config, GUri *uri)
+{
+  GByteArray *bytes;
+  const GstStructure *caps_structure;
+  gchar *filename, *temp_str = NULL;
+  gboolean data_ok = TRUE;
+
+  /* No caching if no expiration date set */
+  if (self->exp_epoch <= 0)
+    return;
+
+  /* Might happen if extractor extract function implementation
+   * returns %TRUE without filling harvest properly */
+  if (G_UNLIKELY (self->caps == NULL || self->buffer == NULL))
+    return; // no data to cache
+
+  bytes = clapper_cache_create ();
+
+  /* If cache disabled */
+  if (G_UNLIKELY (bytes == NULL))
+    return;
+
+  filename = _build_cache_filename (proxy, uri);
+  GST_DEBUG_OBJECT (self, "Exporting harvest to cache file: \"%s\"", filename);
+
+  /* Store enhancer version that generated harvest */
+  clapper_cache_store_string (bytes, clapper_enhancer_proxy_get_version (proxy));
+
+  /* Store expiration date */
+  clapper_cache_store_int64 (bytes, self->exp_epoch);
+
+  /* Store config used to generate harvest */
+  if (config)
+    temp_str = gst_structure_to_string (config);
+  clapper_cache_store_string (bytes, temp_str); // NULL when no config
+  g_clear_pointer (&temp_str, g_free);
+
+  /* Store media type */
+  caps_structure = gst_caps_get_structure (self->caps, 0);
+  if (G_LIKELY (caps_structure != NULL)) {
+    clapper_cache_store_string (bytes, gst_structure_get_name (caps_structure));
+  } else {
+    GST_ERROR_OBJECT (self, "Cannot cache empty caps");
+    data_ok = FALSE;
+  }
+
+  if (G_LIKELY (data_ok)) {
+    GstMemory *mem;
+    GstMapInfo map_info;
+
+    /* Store buffer data */
+    mem = gst_buffer_peek_memory (self->buffer, 0);
+    if (G_LIKELY (gst_memory_map (mem, &map_info, GST_MAP_READ))) {
+      clapper_cache_store_data (bytes, map_info.data, map_info.size);
+      gst_memory_unmap (mem, &map_info);
+    } else {
+      GST_ERROR_OBJECT (self, "Could not map harvest buffer for reading");
+      data_ok = FALSE;
+    }
+  }
+
+  if (G_LIKELY (data_ok)) {
+    GError *error = NULL;
+
+    /* Store tags */
+    if (self->tags)
+      temp_str = gst_tag_list_to_string (self->tags);
+    clapper_cache_store_string (bytes, temp_str);
+    g_clear_pointer (&temp_str, g_free);
+
+    /* Store TOC */
+    _harvest_store_toc_to_cache (self, bytes);
+
+    /* Store headers */
+    if (self->headers)
+      temp_str = gst_structure_to_string (self->headers);
+    clapper_cache_store_string (bytes, temp_str);
+    g_clear_pointer (&temp_str, g_free);
+
+    if (clapper_cache_write (filename, bytes, &error)) {
+      GST_DEBUG_OBJECT (self, "Successfully exported harvest to cache file");
+    } else if (error) {
+      GST_ERROR_OBJECT (self, "Could not cache harvest, reason: %s", error->message);
+      g_error_free (error);
+    }
+  }
+
+  g_free (filename);
+  g_byte_array_free (bytes, TRUE);
+}
+
 /**
  * clapper_harvest_fill:
  * @harvest: a #ClapperHarvest
@@ -155,7 +457,7 @@ clapper_harvest_fill (ClapperHarvest *self, const gchar *media_type, gpointer da
     return FALSE;
   }
 
-  if (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >= GST_LEVEL_DEBUG) {
+  if (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >= GST_LEVEL_LOG) {
     gboolean is_printable = (strcmp (media_type, "application/dash+xml") == 0)
         || (strcmp (media_type, "application/x-hls") == 0)
         || (strcmp (media_type, "text/uri-list") == 0);
@@ -166,7 +468,7 @@ clapper_harvest_fill (ClapperHarvest *self, const gchar *media_type, gpointer da
       data_str = g_new0 (gchar, size + 1);
       memcpy (data_str, data, size);
 
-      GST_DEBUG_OBJECT (self, "Filled with data:\n%s", data_str);
+      GST_LOG_OBJECT (self, "Filled with data:\n%s", data_str);
 
       g_free (data_str);
     }
@@ -328,7 +630,7 @@ clapper_harvest_toc_add (ClapperHarvest *self, GstTocEntryType type,
   g_snprintf (edition, sizeof (edition), "0%i", type);
   g_snprintf (id, sizeof (id), "%s.%" G_GUINT16_FORMAT, id_prefix, nth_entry);
 
-  GST_DEBUG_OBJECT (self, "Inserting TOC %s: \"%s\""
+  GST_LOG_OBJECT (self, "Inserting TOC %s: \"%s\""
       " (%" G_GUINT64_FORMAT "-%" G_GUINT64_FORMAT ")",
       id, title, start_time, end_time);
 
@@ -380,7 +682,7 @@ clapper_harvest_headers_set (ClapperHarvest *self, const gchar *key, ...)
 
   while (key != NULL) {
     const gchar *val = va_arg (args, const gchar *);
-    GST_DEBUG_OBJECT (self, "Set header, \"%s\": \"%s\"", key, val);
+    GST_LOG_OBJECT (self, "Set header, \"%s\": \"%s\"", key, val);
     gst_structure_set (self->headers, key, G_TYPE_STRING, val, NULL);
     key = va_arg (args, const gchar *);
   }
@@ -409,10 +711,70 @@ clapper_harvest_headers_set_value (ClapperHarvest *self, const gchar *key, const
 
   _ensure_headers (self);
 
-  GST_DEBUG_OBJECT (self, "Set header, \"%s\": \"%s\"", key, g_value_get_string (value));
+  GST_LOG_OBJECT (self, "Set header, \"%s\": \"%s\"", key, g_value_get_string (value));
   gst_structure_set_value (self->headers, key, value);
 }
 
+/**
+ * clapper_harvest_set_expiration_date_utc:
+ * @harvest: a #ClapperHarvest
+ * @date_utc: a #GDateTime in UTC time
+ *
+ * Set date in UTC time until harvested content is expected
+ * to stay alive.
+ *
+ * This is used for harvest caching, so next time user requests to
+ * play the same URI, recently harvested data can be reused without
+ * the need to run [vfunc@Clapper.Extractable.extract] again.
+ *
+ * Since: 0.10
+ */
+void
+clapper_harvest_set_expiration_date_utc (ClapperHarvest *self, GDateTime *date_utc)
+{
+  g_return_if_fail (CLAPPER_IS_HARVEST (self));
+  g_return_if_fail (date_utc != NULL);
+
+  self->exp_epoch = g_date_time_to_unix (date_utc);
+  GST_LOG_OBJECT (self, "Expiration epoch: %" G_GINT64_FORMAT, self->exp_epoch);
+}
+
+/**
+ * clapper_harvest_set_expiration_seconds:
+ * @harvest: a #ClapperHarvest
+ * @seconds: time in seconds until expiration
+ *
+ * Set amount of seconds for how long harvested content is
+ * expected to stay alive.
+ *
+ * Alternative function to [method@Clapper.Harvest.set_expiration_date_utc],
+ * but takes time as number in seconds from now.
+ *
+ * It is safe to pass zero or negative number to this function in
+ * case when calculating time manually and it already expired.
+ *
+ * Since: 0.10
+ */
+void
+clapper_harvest_set_expiration_seconds (ClapperHarvest *self, gdouble seconds)
+{
+  GDateTime *date, *date_epoch;
+
+  g_return_if_fail (CLAPPER_IS_HARVEST (self));
+
+  GST_LOG_OBJECT (self, "Set expiration in %" CLAPPER_TIME_FORMAT,
+      CLAPPER_TIME_ARGS (seconds));
+
+  date = g_date_time_new_now_utc ();
+  date_epoch = g_date_time_add_seconds (date, seconds);
+  g_date_time_unref (date);
+
+  self->exp_epoch = g_date_time_to_unix (date_epoch);
+  g_date_time_unref (date_epoch);
+
+  GST_LOG_OBJECT (self, "Expiration epoch: %" G_GINT64_FORMAT, self->exp_epoch);
+}
+
 static void
 clapper_harvest_init (ClapperHarvest *self)
 {

src/lib/clapper/clapper-harvest.h

@@ -61,4 +61,10 @@ void clapper_harvest_headers_set (ClapperHarvest *harvest, const gchar *key, ...
 CLAPPER_API
 void clapper_harvest_headers_set_value (ClapperHarvest *harvest, const gchar *key, const GValue *value);
 
+CLAPPER_API
+void clapper_harvest_set_expiration_date_utc (ClapperHarvest *harvest, GDateTime *date_utc);
+
+CLAPPER_API
+void clapper_harvest_set_expiration_seconds (ClapperHarvest *harvest, gdouble seconds);
+
 G_END_DECLS

src/lib/clapper/clapper-media-item.c

@@ -43,6 +43,7 @@ struct _ClapperMediaItem
   gchar *uri;
   gchar *suburi;
 
+  GstTagList *tags;
   ClapperTimeline *timeline;
 
   guint id;
@@ -56,6 +57,13 @@ struct _ClapperMediaItem
   gboolean used;
 };
 
+typedef struct
+{
+  ClapperMediaItem *item;
+  gboolean changed;
+  gboolean from_user;
+} ClapperMediaItemTagIterData;
+
 enum
 {
   PROP_0,
@@ -63,6 +71,7 @@ enum
   PROP_URI,
   PROP_SUBURI,
   PROP_CACHE_LOCATION,
+  PROP_TAGS,
   PROP_TITLE,
   PROP_CONTAINER_FORMAT,
   PROP_DURATION,
@@ -111,8 +120,8 @@ clapper_media_item_new (const gchar *uri)
 
   /* FIXME: Set initial container format from file extension parsing */
 
-  GST_TRACE_OBJECT (item, "New media item, ID: %u, URI: %s, title: %s",
-      item->id, item->uri, item->title);
+  GST_TRACE_OBJECT (item, "New media item, ID: %u, URI: \"%s\", title: \"%s\"",
+      item->id, item->uri, GST_STR_NULL (item->title));
 
   return item;
 }
@@ -258,27 +267,6 @@ clapper_media_item_get_suburi (ClapperMediaItem *self)
   return suburi;
 }
 
-static gboolean
-clapper_media_item_take_title (ClapperMediaItem *self, gchar *title,
-    ClapperAppBus *app_bus)
-{
-  gboolean changed;
-
-  GST_OBJECT_LOCK (self);
-  if ((changed = g_strcmp0 (self->title, title) != 0)) {
-    g_free (self->title);
-    self->title = title;
-  }
-  GST_OBJECT_UNLOCK (self);
-
-  if (changed)
-    clapper_app_bus_post_prop_notify (app_bus, GST_OBJECT_CAST (self), param_specs[PROP_TITLE]);
-  else
-    g_free (title);
-
-  return changed;
-}
-
 /**
  * clapper_media_item_get_title:
  * @item: a #ClapperMediaItem
@@ -305,25 +293,24 @@ clapper_media_item_get_title (ClapperMediaItem *self)
   return title;
 }
 
-static gboolean
-clapper_media_item_take_container_format (ClapperMediaItem *self, gchar *container_format,
-    ClapperAppBus *app_bus)
+static inline gboolean
+_refresh_tag_prop_unlocked (ClapperMediaItem *self, const gchar *tag,
+    gboolean from_user, gchar **tag_ptr)
 {
-  gboolean changed;
+  const gchar *string;
 
-  GST_OBJECT_LOCK (self);
-  if ((changed = g_strcmp0 (self->container_format, container_format) != 0)) {
-    g_free (self->container_format);
-    self->container_format = container_format;
-  }
-  GST_OBJECT_UNLOCK (self);
+  if ((*tag_ptr && from_user) // if already set, user cannot modify it
+      || !gst_tag_list_peek_string_index (self->tags, tag, 0, &string) // guarantees non-empty string
+      || (g_strcmp0 (*tag_ptr, string) == 0))
+    return FALSE;
 
-  if (changed)
-    clapper_app_bus_post_prop_notify (app_bus, GST_OBJECT_CAST (self), param_specs[PROP_CONTAINER_FORMAT]);
-  else
-    g_free (container_format);
+  GST_LOG_OBJECT (self, "Tag prop \"%s\" update: \"%s\" -> \"%s\"",
+      tag, GST_STR_NULL (*tag_ptr), string);
 
-  return changed;
+  g_free (*tag_ptr);
+  *tag_ptr = g_strdup (string);
+
+  return TRUE;
 }
 
 /**
@@ -333,6 +320,8 @@ clapper_media_item_take_container_format (ClapperMediaItem *self, gchar *contain
  * Get media item container format.
  *
  * Returns: (transfer full) (nullable): media container format.
+ *
+ * Deprecated: 0.10: Get `container-format` from [property@Clapper.MediaItem:tags] instead.
  */
 gchar *
 clapper_media_item_get_container_format (ClapperMediaItem *self)
@@ -389,11 +378,207 @@ clapper_media_item_get_duration (ClapperMediaItem *self)
   return duration;
 }
 
+/**
+ * clapper_media_item_get_tags:
+ * @item: a #ClapperMediaItem
+ *
+ * Get readable list of tags stored in media item.
+ *
+ * Returns: (transfer full): a #GstTagList.
+ *
+ * Since: 0.10
+ */
+GstTagList *
+clapper_media_item_get_tags (ClapperMediaItem *self)
+{
+  GstTagList *tags = NULL;
+
+  g_return_val_if_fail (CLAPPER_IS_MEDIA_ITEM (self), NULL);
+
+  GST_OBJECT_LOCK (self);
+  tags = gst_tag_list_ref (self->tags);
+  GST_OBJECT_UNLOCK (self);
+
+  return tags;
+}
+
+static void
+_tags_replace_func (const GstTagList *tags, const gchar *tag, ClapperMediaItemTagIterData *data)
+{
+  ClapperMediaItem *self = data->item;
+  guint index = 0;
+  gboolean replace = FALSE;
+
+  while (TRUE) {
+    const GValue *old_value = gst_tag_list_get_value_index (self->tags, tag, index);
+    const GValue *new_value = gst_tag_list_get_value_index (tags, tag, index);
+
+    /* Number of old values is the same or greater and
+     * all values until this iteration were the same */
+    if (!new_value)
+      break;
+
+    /* A wild new tag appeared */
+    if (!old_value) {
+      replace = TRUE;
+      break;
+    }
+
+    /* Users can only set non-existing tags */
+    if (data->from_user)
+      break;
+
+    /* Check with tolerance for doubles */
+    if (G_VALUE_TYPE (old_value) == G_TYPE_DOUBLE
+        && G_VALUE_TYPE (new_value) == G_TYPE_DOUBLE) {
+      gdouble old_dbl, new_dbl;
+
+      old_dbl = g_value_get_double (old_value);
+      new_dbl = g_value_get_double (new_value);
+
+      if ((replace = !G_APPROX_VALUE (old_dbl, new_dbl, FLT_EPSILON)))
+        break;
+    } else if (gst_value_compare (old_value, new_value) != GST_VALUE_EQUAL) {
+      replace = TRUE;
+      break;
+    }
+
+    ++index;
+  }
+
+  if (replace) {
+    const GValue *value;
+    index = 0;
+
+    GST_LOG_OBJECT (self, "Replacing \"%s\" tag value", tag);
+
+    /* Ensure writable, but only when replacing something */
+    if (!data->changed) {
+      self->tags = gst_tag_list_make_writable (self->tags);
+      data->changed = TRUE;
+    }
+
+    /* Replace first tag value (so it becomes sole member) */
+    value = gst_tag_list_get_value_index (tags, tag, index);
+    gst_tag_list_add_value (self->tags, GST_TAG_MERGE_REPLACE, tag, value);
+
+    /* Append any remaining tags (so next time we iterate indexes will match) */
+    while ((value = gst_tag_list_get_value_index (tags, tag, ++index)))
+      gst_tag_list_add_value (self->tags, GST_TAG_MERGE_APPEND, tag, value);
+  }
+}
+
+static gboolean
+clapper_media_item_insert_tags_internal (ClapperMediaItem *self, const GstTagList *tags,
+    ClapperAppBus *app_bus, gboolean from_user)
+{
+  ClapperMediaItemTagIterData data;
+  gboolean title_changed = FALSE, cont_changed = FALSE;
+
+  GST_OBJECT_LOCK (self);
+
+  data.item = self;
+  data.changed = FALSE;
+  data.from_user = from_user;
+
+  if (G_LIKELY (tags != self->tags))
+    gst_tag_list_foreach (tags, (GstTagForeachFunc) _tags_replace_func, &data);
+
+  if (data.changed) {
+    title_changed = _refresh_tag_prop_unlocked (self, GST_TAG_TITLE,
+        from_user, &self->title);
+    cont_changed = _refresh_tag_prop_unlocked (self, GST_TAG_CONTAINER_FORMAT,
+        from_user, &self->container_format);
+  }
+
+  GST_OBJECT_UNLOCK (self);
+
+  if (!data.changed)
+    return FALSE;
+
+  if (app_bus) {
+    GstObject *src = GST_OBJECT_CAST (self);
+
+    clapper_app_bus_post_prop_notify (app_bus, src, param_specs[PROP_TAGS]);
+
+    if (title_changed)
+      clapper_app_bus_post_prop_notify (app_bus, src, param_specs[PROP_TITLE]);
+    if (cont_changed)
+      clapper_app_bus_post_prop_notify (app_bus, src, param_specs[PROP_CONTAINER_FORMAT]);
+  } else {
+    GObject *src = G_OBJECT (self);
+
+    clapper_utils_prop_notify_on_main_sync (src, param_specs[PROP_TAGS]);
+
+    if (title_changed)
+      clapper_utils_prop_notify_on_main_sync (src, param_specs[PROP_TITLE]);
+    if (cont_changed)
+      clapper_utils_prop_notify_on_main_sync (src, param_specs[PROP_CONTAINER_FORMAT]);
+  }
+
+  return TRUE;
+}
+
+/**
+ * clapper_media_item_populate_tags:
+ * @item: a #ClapperMediaItem
+ * @tags: a #GstTagList of GLOBAL scope
+ *
+ * Populate non-existing tags in @item tag list.
+ *
+ * Passed @tags must use [enum@Gst.TagScope.GLOBAL] scope.
+ *
+ * Note that tags are automatically determined during media playback
+ * and those take precedence. This function can be useful if an app can
+ * determine some tags that are not in media metadata or for filling
+ * item with some initial/cached tags to display in UI before playback.
+ *
+ * When a tag already exists in the tag list (was populated) this
+ * function will not overwrite it. If you really need to permanently
+ * override some tags in media, you can use `taginject` element as
+ * player video/audio filter instead.
+ *
+ * Returns: whether at least one tag got updated.
+ *
+ * Since: 0.10
+ */
+gboolean
+clapper_media_item_populate_tags (ClapperMediaItem *self, const GstTagList *tags)
+{
+  ClapperPlayer *player;
+  ClapperAppBus *app_bus = NULL;
+  gboolean changed;
+
+  g_return_val_if_fail (CLAPPER_IS_MEDIA_ITEM (self), FALSE);
+  g_return_val_if_fail (tags != NULL, FALSE);
+
+  if (G_UNLIKELY (gst_tag_list_get_scope (tags) != GST_TAG_SCOPE_GLOBAL)) {
+    g_warning ("Cannot populate media item tags using a list with non-global tag scope");
+    return FALSE;
+  }
+
+  if ((player = clapper_player_get_from_ancestor (GST_OBJECT_CAST (self))))
+    app_bus = player->app_bus;
+
+  changed = clapper_media_item_insert_tags_internal (self, tags, app_bus, TRUE);
+
+  if (changed && player) {
+    ClapperFeaturesManager *features_manager;
+
+    if ((features_manager = clapper_player_get_features_manager (player)))
+      clapper_features_manager_trigger_item_updated (features_manager, self);
+  }
+
+  gst_clear_object (&player);
+
+  return changed;
+}
+
 /**
  * clapper_media_item_get_timeline:
  * @item: a #ClapperMediaItem
  *
- * Get the [class@Clapper.Timeline] assosiated with @item.
+ * Get the [class@Clapper.Timeline] associated with @item.
  *
  * Returns: (transfer none): a #ClapperTimeline of item.
  */
@@ -405,21 +590,6 @@ clapper_media_item_get_timeline (ClapperMediaItem *self)
   return self->timeline;
 }
 
-static gboolean
-clapper_media_item_update_from_container_tags (ClapperMediaItem *self, const GstTagList *tags,
-    ClapperAppBus *app_bus)
-{
-  gchar *string = NULL;
-  gboolean changed = FALSE;
-
-  if (gst_tag_list_get_string (tags, GST_TAG_CONTAINER_FORMAT, &string))
-    changed |= clapper_media_item_take_container_format (self, string, app_bus);
-  if (gst_tag_list_get_string (tags, GST_TAG_TITLE, &string))
-    changed |= clapper_media_item_take_title (self, string, app_bus);
-
-  return changed;
-}
-
 void
 clapper_media_item_update_from_tag_list (ClapperMediaItem *self, const GstTagList *tags,
     ClapperPlayer *player)
@@ -427,7 +597,7 @@ clapper_media_item_update_from_tag_list (ClapperMediaItem *self, const GstTagLis
   GstTagScope scope = gst_tag_list_get_scope (tags);
 
   if (scope == GST_TAG_SCOPE_GLOBAL) {
-    gboolean changed = clapper_media_item_update_from_container_tags (self, tags, player->app_bus);
+    gboolean changed = clapper_media_item_insert_tags_internal (self, tags, player->app_bus, FALSE);
 
     if (changed) {
       ClapperFeaturesManager *features_manager;
@@ -459,7 +629,7 @@ clapper_media_item_update_from_discoverer_info (ClapperMediaItem *self, GstDisco
       GstDiscovererContainerInfo *cinfo = (GstDiscovererContainerInfo *) sinfo;
 
       if ((tags = gst_discoverer_container_info_get_tags (cinfo)))
-        changed |= clapper_media_item_update_from_container_tags (self, tags, player->app_bus);
+        changed |= clapper_media_item_insert_tags_internal (self, tags, player->app_bus, FALSE);
     }
     gst_discoverer_stream_info_unref (sinfo);
   }
@@ -542,6 +712,9 @@ clapper_media_item_get_used (ClapperMediaItem *self)
 static void
 clapper_media_item_init (ClapperMediaItem *self)
 {
+  self->tags = gst_tag_list_new_empty ();
+  gst_tag_list_set_scope (self->tags, GST_TAG_SCOPE_GLOBAL);
+
   self->timeline = clapper_timeline_new ();
   gst_object_set_parent (GST_OBJECT_CAST (self->timeline), GST_OBJECT_CAST (self));
 }
@@ -571,6 +744,8 @@ clapper_media_item_finalize (GObject *object)
   g_free (self->title);
   g_free (self->container_format);
 
+  gst_tag_list_unref (self->tags);
+
   gst_object_unparent (GST_OBJECT_CAST (self->timeline));
   gst_object_unref (self->timeline);
 
@@ -617,6 +792,9 @@ clapper_media_item_get_property (GObject *object, guint prop_id,
     case PROP_SUBURI:
       g_value_take_string (value, clapper_media_item_get_suburi (self));
       break;
+    case PROP_TAGS:
+      g_value_take_boxed (value, clapper_media_item_get_tags (self));
+      break;
     case PROP_TITLE:
       g_value_take_string (value, clapper_media_item_get_title (self));
       break;
@@ -686,10 +864,27 @@ clapper_media_item_class_init (ClapperMediaItemClass *klass)
       NULL, NULL, NULL,
       G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
+  /**
+   * ClapperMediaItem:tags:
+   *
+   * A readable list of tags stored in media item.
+   *
+   * Since: 0.10
+   */
+  param_specs[PROP_TAGS] = g_param_spec_boxed ("tags",
+      NULL, NULL, GST_TYPE_TAG_LIST,
+      G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /* FIXME: 1.0: Consider rename to e.g. "(menu/display)-title"
+   * and also make it non-nullable (return URI as final fallback) */
   /**
    * ClapperMediaItem:title:
    *
    * Media title.
+   *
+   * This might be a different string compared to `title` from
+   * [property@Clapper.MediaItem:tags], as this gives parsed
+   * title from file name/URI as fallback when no `title` tag.
    */
   param_specs[PROP_TITLE] = g_param_spec_string ("title",
       NULL, NULL, NULL,
@@ -699,15 +894,21 @@ clapper_media_item_class_init (ClapperMediaItemClass *klass)
    * ClapperMediaItem:container-format:
    *
    * Media container format.
+   *
+   * Deprecated: 0.10: Get `container-format` from [property@Clapper.MediaItem:tags] instead.
    */
   param_specs[PROP_CONTAINER_FORMAT] = g_param_spec_string ("container-format",
       NULL, NULL, NULL,
-      G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+      G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS | G_PARAM_DEPRECATED);
 
   /**
    * ClapperMediaItem:duration:
    *
    * Media duration as a decimal number in seconds.
+   *
+   * This might be a different value compared to `duration` from
+   * [property@Clapper.MediaItem:tags], as this value is updated
+   * during decoding instead of being a fixed value from metadata.
    */
   param_specs[PROP_DURATION] = g_param_spec_double ("duration",
       NULL, NULL, 0, G_MAXDOUBLE, 0,

src/lib/clapper/clapper-media-item.h

@@ -27,6 +27,7 @@
 #include <glib-object.h>
 #include <gio/gio.h>
 #include <gst/gst.h>
+#include <gst/tag/tag.h>
 
 #include <clapper/clapper-visibility.h>
 #include <clapper/clapper-timeline.h>
@@ -63,12 +64,18 @@ gchar * clapper_media_item_get_suburi (ClapperMediaItem *item);
 CLAPPER_API
 gchar * clapper_media_item_get_title (ClapperMediaItem *item);
 
-CLAPPER_API
+CLAPPER_DEPRECATED_FOR(clapper_media_item_get_tags)
 gchar * clapper_media_item_get_container_format (ClapperMediaItem *item);
 
 CLAPPER_API
 gdouble clapper_media_item_get_duration (ClapperMediaItem *item);
 
+CLAPPER_API
+GstTagList * clapper_media_item_get_tags (ClapperMediaItem *item);
+
+CLAPPER_API
+gboolean clapper_media_item_populate_tags (ClapperMediaItem *item, const GstTagList *tags);
+
 CLAPPER_API
 ClapperTimeline * clapper_media_item_get_timeline (ClapperMediaItem *item);
 

src/lib/clapper/clapper-playbin-bus.c

@@ -29,12 +29,7 @@
 #include "clapper-timeline-private.h"
 #include "clapper-stream-private.h"
 #include "clapper-stream-list-private.h"
-
-#include "clapper-functionalities-availability.h"
-
-#if CLAPPER_WITH_ENHANCERS_LOADER
-#include "gst/clapper-enhancer-src-private.h"
-#endif
+#include "gst/clapper-extractable-src-private.h"
 
 #define GST_CAT_DEFAULT clapper_playbin_bus_debug
 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
@@ -875,7 +870,6 @@ _handle_tag_msg (GstMessage *msg, ClapperPlayer *player)
 {
   GstObject *src = GST_MESSAGE_SRC (msg);
   GstTagList *tags = NULL;
-  gboolean from_enhancer_src;
 
   /* Tag messages should only be posted by sink elements */
   if (G_UNLIKELY (!src))
@@ -886,14 +880,8 @@ _handle_tag_msg (GstMessage *msg, ClapperPlayer *player)
   GST_LOG_OBJECT (player, "Got tags from element: %s: %" GST_PTR_FORMAT,
       GST_OBJECT_NAME (src), tags);
 
-#if CLAPPER_WITH_ENHANCERS_LOADER
-  from_enhancer_src = CLAPPER_IS_ENHANCER_SRC (src);
-#else
-  from_enhancer_src = FALSE;
-#endif
-
-  /* ClapperEnhancerSrc determines tags before stream start */
-  if (from_enhancer_src) {
+  /* ClapperExtractableSrc determines tags before stream start */
+  if (CLAPPER_IS_EXTRACTABLE_SRC (src)) {
     if (player->pending_tags) {
       gst_tag_list_unref (player->pending_tags);
     }
@@ -910,7 +898,7 @@ _handle_toc_msg (GstMessage *msg, ClapperPlayer *player)
 {
   GstObject *src = GST_MESSAGE_SRC (msg);
   GstToc *toc = NULL;
-  gboolean from_enhancer_src, updated = FALSE;
+  gboolean updated = FALSE;
 
   /* TOC messages should only be posted by sink elements */
   if (G_UNLIKELY (!src))
@@ -923,14 +911,8 @@ _handle_toc_msg (GstMessage *msg, ClapperPlayer *player)
       " from element: %s, updated: %s",
       toc, GST_OBJECT_NAME (src), (updated) ? "yes" : "no");
 
-#if CLAPPER_WITH_ENHANCERS_LOADER
-  from_enhancer_src = CLAPPER_IS_ENHANCER_SRC (src);
-#else
-  from_enhancer_src = FALSE;
-#endif
-
-  /* ClapperEnhancerSrc determines TOC before stream start */
-  if (from_enhancer_src) {
+  /* ClapperExtractableSrc determines TOC before stream start */
+  if (CLAPPER_IS_EXTRACTABLE_SRC (src)) {
     if (player->pending_toc) {
       gst_toc_unref (player->pending_toc);
     }

src/lib/clapper/clapper-player.c

@@ -816,7 +816,7 @@ _element_setup_cb (GstElement *playbin, GstElement *element, ClapperPlayer *self
   factory_name = g_intern_static_string (GST_OBJECT_NAME (factory));
   GST_INFO_OBJECT (self, "Element setup: %s", factory_name);
 
-  if (factory_name == g_intern_static_string ("clapperenhancersrc")) {
+  if (factory_name == g_intern_static_string ("clapperextractablesrc")) {
     g_object_set (element,
         "enhancer-proxies", self->enhancer_proxies,
         NULL);
@@ -2833,7 +2833,7 @@ clapper_player_class_init (ClapperPlayerClass *klass)
    * An initial bitrate (bits/s) to select during
    * starting adaptive streaming such as DASH or HLS.
    *
-   * If value is higher than lowest available bitrate in streaming
+   * If value is lower than the lowest available bitrate in streaming
    * manifest, then lowest possible bitrate will be selected.
    *
    * Since: 0.8

src/lib/clapper/clapper-threaded-object.c

@@ -52,7 +52,7 @@ G_DEFINE_TYPE_WITH_PRIVATE (ClapperThreadedObject, clapper_threaded_object, GST_
  * Useful when you want to invoke object thread to do some
  * action in it from a different thread.
  *
- * Returns: a #GMainContext of the object used thread.
+ * Returns: (transfer none): a #GMainContext of the object used thread.
  */
 GMainContext *
 clapper_threaded_object_get_context (ClapperThreadedObject *self)

src/lib/clapper/clapper-utils-private.h

@@ -45,6 +45,9 @@ void clapper_utils_queue_remove_on_main_sync (ClapperQueue *queue, ClapperMediaI
 G_GNUC_INTERNAL
 void clapper_utils_queue_clear_on_main_sync (ClapperQueue *queue);
 
+G_GNUC_INTERNAL
+void clapper_utils_prop_notify_on_main_sync (GObject *object, GParamSpec *pspec);
+
 G_GNUC_INTERNAL
 gchar * clapper_utils_uri_from_file (GFile *file);
 

src/lib/clapper/clapper-utils.c

@@ -39,6 +39,12 @@ typedef struct
   ClapperUtilsQueueAlterMethod method;
 } ClapperUtilsQueueAlterData;
 
+typedef struct
+{
+  GObject *object;
+  GParamSpec *pspec;
+} ClapperUtilsPropNotifyData;
+
 void
 clapper_utils_initialize (void)
 {
@@ -71,6 +77,27 @@ clapper_utils_queue_alter_data_free (ClapperUtilsQueueAlterData *data)
   g_free (data);
 }
 
+static ClapperUtilsPropNotifyData *
+clapper_utils_prop_notify_data_new (GObject *object, GParamSpec *pspec)
+{
+  ClapperUtilsPropNotifyData *data = g_new (ClapperUtilsPropNotifyData, 1);
+
+  data->object = object;
+  data->pspec = pspec;
+
+  GST_TRACE ("Created prop notify data: %p", data);
+
+  return data;
+}
+
+static void
+clapper_utils_prop_notify_data_free (ClapperUtilsPropNotifyData *data)
+{
+  GST_TRACE ("Freeing prop notify data: %p", data);
+
+  g_free (data);
+}
+
 static gpointer
 clapper_utils_queue_alter_on_main (ClapperUtilsQueueAlterData *data)
 {
@@ -110,6 +137,15 @@ clapper_utils_queue_alter_on_main (ClapperUtilsQueueAlterData *data)
   return NULL;
 }
 
+static gpointer
+clapper_utils_prop_notify_on_main (ClapperUtilsPropNotifyData *data)
+{
+  GST_DEBUG ("Prop notify invoked");
+  g_object_notify_by_pspec (data->object, data->pspec);
+
+  return NULL;
+}
+
 static inline void
 clapper_utils_queue_alter_invoke_on_main_sync_take (ClapperUtilsQueueAlterData *data)
 {
@@ -155,6 +191,27 @@ clapper_utils_queue_clear_on_main_sync (ClapperQueue *queue)
   clapper_utils_queue_alter_invoke_on_main_sync_take (data);
 }
 
+void
+clapper_utils_prop_notify_on_main_sync (GObject *object, GParamSpec *pspec)
+{
+  ClapperUtilsPropNotifyData *data;
+
+  if (g_main_context_is_owner (g_main_context_default ())) { // already in main thread
+    g_object_notify_by_pspec (object, pspec);
+    return;
+  }
+
+  data = clapper_utils_prop_notify_data_new (object, pspec);
+
+  GST_DEBUG ("Invoking prop notify on main...");
+
+  clapper_shared_utils_context_invoke_sync_full (g_main_context_default (),
+      (GThreadFunc) clapper_utils_prop_notify_on_main, data,
+      (GDestroyNotify) clapper_utils_prop_notify_data_free);
+
+  GST_DEBUG ("Prop notify invoke finished");
+}
+
 gchar *
 clapper_utils_uri_from_file (GFile *file)
 {

src/lib/clapper/gst/clapper-enhancer-director.c

@@ -17,12 +17,17 @@
  * Boston, MA 02110-1301, USA.
  */
 
+#include "config.h"
+
 #include <gst/gst.h>
 
 #include "clapper-enhancer-director-private.h"
+#include "../clapper-basic-functions.h"
+#include "../clapper-cache-private.h"
 #include "../clapper-enhancer-proxy-private.h"
 #include "../clapper-extractable-private.h"
 #include "../clapper-harvest-private.h"
+#include "../clapper-utils.h"
 #include "../../shared/clapper-shared-utils-private.h"
 
 #include "../clapper-functionalities-availability.h"
@@ -31,6 +36,8 @@
 #include "../clapper-enhancers-loader-private.h"
 #endif
 
+#define CLEANUP_INTERVAL 10800 // once every 3 hours
+
 #define GST_CAT_DEFAULT clapper_enhancer_director_debug
 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
 
@@ -57,7 +64,7 @@ clapper_enhancer_director_extract_in_thread (ClapperEnhancerDirectorData *data)
   ClapperEnhancerDirector *self = data->director;
   GList *el;
   ClapperHarvest *harvest = NULL;
-  gboolean success = FALSE, cached = FALSE;
+  gboolean success = FALSE;
 
   GST_DEBUG_OBJECT (self, "Extraction start");
 
@@ -65,22 +72,22 @@ clapper_enhancer_director_extract_in_thread (ClapperEnhancerDirectorData *data)
   if (g_cancellable_is_cancelled (data->cancellable))
     return NULL;
 
-  /* TODO: Cache lookup */
-  if (cached) {
-    // if ((success = fill harvest from cache))
-    //   return harvest;
-  }
-
   GST_DEBUG_OBJECT (self, "Enhancer proxies for URI: %u",
       g_list_length (data->filtered_proxies));
 
   for (el = data->filtered_proxies; el; el = g_list_next (el)) {
     ClapperEnhancerProxy *proxy = CLAPPER_ENHANCER_PROXY_CAST (el->data);
     ClapperExtractable *extractable = NULL;
+    GstStructure *config;
 
-    /* Check just before extract */
-    if (g_cancellable_is_cancelled (data->cancellable))
+    harvest = clapper_harvest_new (); // fresh harvest for each iteration
+    config = clapper_enhancer_proxy_make_current_config (proxy);
+
+    if ((success = clapper_harvest_fill_from_cache (harvest, proxy, config, data->uri))
+        || g_cancellable_is_cancelled (data->cancellable)) { // Check before extract
+      gst_clear_structure (&config);
       break;
+    }
 
 #if CLAPPER_WITH_ENHANCERS_LOADER
     extractable = CLAPPER_EXTRACTABLE_CAST (
@@ -88,32 +95,33 @@ clapper_enhancer_director_extract_in_thread (ClapperEnhancerDirectorData *data)
 #endif
 
     if (G_LIKELY (extractable != NULL)) {
-      clapper_enhancer_proxy_apply_current_config_to_enhancer (proxy, (GObject *) extractable);
-
-      harvest = clapper_harvest_new (); // fresh harvest for each extractable
+      if (config)
+        clapper_enhancer_proxy_apply_config_to_enhancer (proxy, config, (GObject *) extractable);
 
       success = clapper_extractable_extract (extractable, data->uri,
           harvest, data->cancellable, data->error);
       gst_object_unref (extractable);
 
-      /* We are done with extractable, but keep its harvest */
-      if (success)
-        break;
+      /* We are done with extractable, but keep harvest and try to cache it */
+      if (success) {
+        if (!g_cancellable_is_cancelled (data->cancellable))
+          clapper_harvest_export_to_cache (harvest, proxy, config, data->uri);
 
-      /* Clear harvest and try again with next enhancer */
-      g_clear_object (&harvest);
+        gst_clear_structure (&config);
+        break;
+      }
     }
+
+    /* Cleanup to try again with next enhancer */
+    g_clear_object (&harvest);
+    gst_clear_structure (&config);
   }
 
-  /* Cancelled during extract */
+  /* Cancelled during extraction or exporting to cache */
   if (g_cancellable_is_cancelled (data->cancellable))
     success = FALSE;
 
-  if (success) {
-    if (!cached) {
-      /* TODO: Store in cache */
-    }
-  } else {
+  if (!success) {
     gst_clear_object (&harvest);
 
     /* Ensure we have some error set on failure */
@@ -131,6 +139,171 @@ clapper_enhancer_director_extract_in_thread (ClapperEnhancerDirectorData *data)
   return harvest;
 }
 
+static inline void
+_harvest_delete_if_expired (ClapperEnhancerDirector *self,
+    ClapperEnhancerProxy *proxy, GFile *file, const gint64 epoch_now)
+{
+  GMappedFile *mapped_file;
+  const gchar *data;
+  gchar *filename;
+  GError *error = NULL;
+  gboolean delete = TRUE;
+
+  filename = g_file_get_path (file);
+
+  if ((mapped_file = clapper_cache_open (filename, &data, &error))) {
+    /* Do not delete if versions match and not expired */
+    if (g_strcmp0 (clapper_cache_read_string (&data),
+        clapper_enhancer_proxy_get_version (proxy)) == 0
+        && clapper_cache_read_int64 (&data) > epoch_now) {
+      delete = FALSE;
+    }
+    g_mapped_file_unref (mapped_file);
+  } else if (error) {
+    if (error->domain == G_FILE_ERROR && error->code == G_FILE_ERROR_NOENT)
+      GST_DEBUG_OBJECT (self, "No cached harvest file found");
+    else
+      GST_ERROR_OBJECT (self, "Could not read cached harvest file, reason: %s", error->message);
+
+    g_clear_error (&error);
+  }
+
+  if (delete) {
+    if (G_LIKELY (g_file_delete (file, NULL, &error))) {
+      GST_TRACE_OBJECT (self, "Deleted cached harvest: \"%s\"", filename);
+    } else {
+      GST_ERROR_OBJECT (self, "Could not delete harvest: \"%s\", reason: %s",
+          filename, GST_STR_NULL (error->message));
+      g_error_free (error);
+    }
+  }
+
+  g_free (filename);
+}
+
+static inline void
+_cache_proxy_harvests_cleanup (ClapperEnhancerDirector *self,
+    ClapperEnhancerProxy *proxy, const gint64 epoch_now)
+{
+  GFile *dir;
+  GFileEnumerator *dir_enum;
+  GError *error = NULL;
+
+  dir = g_file_new_build_filename (g_get_user_cache_dir (), CLAPPER_API_NAME,
+      "enhancers", clapper_enhancer_proxy_get_module_name (proxy),
+      "harvests", NULL);
+
+  if ((dir_enum = g_file_enumerate_children (dir,
+      G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE,
+      G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &error))) {
+    while (TRUE) {
+      GFileInfo *info = NULL;
+      GFile *child = NULL;
+
+      if (!g_file_enumerator_iterate (dir_enum, &info,
+          &child, NULL, &error) || !info)
+        break;
+
+      if (G_LIKELY (g_file_info_get_file_type (info) == G_FILE_TYPE_REGULAR
+          && g_str_has_suffix (g_file_info_get_name (info), ".bin")))
+        _harvest_delete_if_expired (self, proxy, child, epoch_now);
+    }
+
+    g_object_unref (dir_enum);
+  }
+
+  if (error) {
+    if (error->domain != G_IO_ERROR || error->code != G_IO_ERROR_NOT_FOUND) {
+      gchar *path = g_file_get_path (dir);
+
+      GST_ERROR_OBJECT (self, "Could not cleanup in dir: \"%s\", reason: %s",
+          path, GST_STR_NULL (error->message));
+      g_free (path);
+    }
+
+    g_error_free (error);
+  }
+
+  g_object_unref (dir);
+}
+
+static gboolean
+_cache_cleanup_func (ClapperEnhancerDirector *self)
+{
+  GMappedFile *mapped_file;
+  GDateTime *date;
+  GError *error = NULL;
+  gchar *filename;
+  const gchar *data;
+  gint64 since_cleanup, epoch_now, epoch_last = 0;
+
+  date = g_date_time_new_now_utc ();
+  epoch_now = g_date_time_to_unix (date);
+  g_date_time_unref (date);
+
+  filename = g_build_filename (g_get_user_cache_dir (), CLAPPER_API_NAME,
+      "enhancers", "cleanup.bin", NULL);
+
+  if ((mapped_file = clapper_cache_open (filename, &data, &error))) {
+    epoch_last = clapper_cache_read_int64 (&data);
+    g_mapped_file_unref (mapped_file);
+  } else if (error) {
+    if (error->domain == G_FILE_ERROR && error->code == G_FILE_ERROR_NOENT)
+      GST_DEBUG_OBJECT (self, "No cache cleanup file found");
+    else
+      GST_ERROR_OBJECT (self, "Could not read cache cleanup file, reason: %s", error->message);
+
+    g_clear_error (&error);
+  }
+
+  since_cleanup = epoch_now - epoch_last;
+
+  if (since_cleanup >= CLEANUP_INTERVAL) {
+    ClapperEnhancerProxyList *proxies;
+    guint i, n_proxies;
+    GByteArray *bytes;
+
+    GST_TRACE_OBJECT (self, "Time for cache cleanup, last was %"
+        CLAPPER_TIME_FORMAT " ago", CLAPPER_TIME_ARGS (since_cleanup));
+
+    /* Start with writing to cache cleanup time,
+     * so other directors can find it earlier */
+    if ((bytes = clapper_cache_create ())) {
+      clapper_cache_store_int64 (bytes, epoch_now);
+
+      if (clapper_cache_write (filename, bytes, &error)) {
+        GST_TRACE_OBJECT (self, "Written data to cache cleanup file, cleanup time: %"
+            G_GINT64_FORMAT, epoch_now);
+      } else if (error) {
+        GST_ERROR_OBJECT (self, "Could not write cache cleanup data, reason: %s", error->message);
+        g_clear_error (&error);
+      }
+
+      g_byte_array_free (bytes, TRUE);
+    }
+
+    /* Now do cleanup */
+    proxies = clapper_get_global_enhancer_proxies ();
+    n_proxies = clapper_enhancer_proxy_list_get_n_proxies (proxies);
+
+    for (i = 0; i < n_proxies; ++i) {
+      ClapperEnhancerProxy *proxy = clapper_enhancer_proxy_list_peek_proxy (proxies, i);
+
+      if (!clapper_enhancer_proxy_target_has_interface (proxy, CLAPPER_TYPE_EXTRACTABLE))
+        continue;
+
+      _cache_proxy_harvests_cleanup (self, proxy, epoch_now);
+    }
+  } else {
+    GST_TRACE_OBJECT (self, "No cache cleanup yet, last was %"
+        CLAPPER_TIME_FORMAT " ago", CLAPPER_TIME_ARGS (since_cleanup));
+  }
+
+  g_free (filename);
+
+  return G_SOURCE_REMOVE;
+}
+
 /*
  * clapper_enhancer_director_new:
  *
@@ -153,6 +326,8 @@ clapper_enhancer_director_extract (ClapperEnhancerDirector *self,
     GCancellable *cancellable, GError **error)
 {
   ClapperEnhancerDirectorData *data = g_new (ClapperEnhancerDirectorData, 1);
+  GMainContext *context;
+  ClapperHarvest *harvest;
 
   data->director = self;
   data->filtered_proxies = filtered_proxies;
@@ -160,10 +335,18 @@ clapper_enhancer_director_extract (ClapperEnhancerDirector *self,
   data->cancellable = cancellable;
   data->error = error;
 
-  return CLAPPER_HARVEST_CAST (clapper_shared_utils_context_invoke_sync_full (
-      clapper_threaded_object_get_context (CLAPPER_THREADED_OBJECT_CAST (self)),
+  context = clapper_threaded_object_get_context (CLAPPER_THREADED_OBJECT_CAST (self));
+
+  harvest = CLAPPER_HARVEST_CAST (clapper_shared_utils_context_invoke_sync_full (context,
       (GThreadFunc) clapper_enhancer_director_extract_in_thread,
       data, (GDestroyNotify) g_free));
+
+  /* Run cleanup async. Since context belongs to "self", do not ref it.
+   * This ensures clean shutdown with thread stop function called. */
+  if (!g_cancellable_is_cancelled (cancellable) && !clapper_cache_is_disabled ())
+    g_main_context_invoke (context, (GSourceFunc) _cache_cleanup_func, self);
+
+  return harvest;
 }
 
 static void

src/lib/clapper/gst/clapper-extractable-src-private.h

@@ -26,12 +26,12 @@
 
 G_BEGIN_DECLS
 
-#define CLAPPER_TYPE_ENHANCER_SRC (clapper_enhancer_src_get_type())
-#define CLAPPER_ENHANCER_SRC_CAST(obj) ((ClapperEnhancerSrc *)(obj))
+#define CLAPPER_TYPE_EXTRACTABLE_SRC (clapper_extractable_src_get_type())
+#define CLAPPER_EXTRACTABLE_SRC_CAST(obj) ((ClapperExtractableSrc *)(obj))
 
 G_GNUC_INTERNAL
-G_DECLARE_FINAL_TYPE (ClapperEnhancerSrc, clapper_enhancer_src, CLAPPER, ENHANCER_SRC, GstPushSrc)
+G_DECLARE_FINAL_TYPE (ClapperExtractableSrc, clapper_extractable_src, CLAPPER, EXTRACTABLE_SRC, GstPushSrc)
 
-GST_ELEMENT_REGISTER_DECLARE (clapperenhancersrc)
+GST_ELEMENT_REGISTER_DECLARE (clapperextractablesrc)
 
 G_END_DECLS

src/lib/clapper/gst/clapper-extractable-src.c

@@ -19,7 +19,7 @@
 
 #include "config.h"
 
-#include "clapper-enhancer-src-private.h"
+#include "clapper-extractable-src-private.h"
 #include "clapper-enhancer-director-private.h"
 
 #include "../clapper-basic-functions.h"
@@ -28,13 +28,13 @@
 #include "../clapper-extractable.h"
 #include "../clapper-harvest-private.h"
 
-#define GST_CAT_DEFAULT clapper_enhancer_src_debug
+#define GST_CAT_DEFAULT clapper_extractable_src_debug
 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
 
 #define CHECK_SCHEME_IS_HTTPS(scheme) (g_str_has_prefix (scheme, "http") \
     && (scheme[4] == '\0' || (scheme[4] == 's' && scheme[5] == '\0')))
 
-struct _ClapperEnhancerSrc
+struct _ClapperExtractableSrc
 {
   GstPushSrc parent;
 
@@ -65,7 +65,7 @@ static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
     GST_STATIC_CAPS_ANY);
 
 static GstURIType
-clapper_enhancer_src_uri_handler_get_type (GType type)
+clapper_extractable_src_uri_handler_get_type (GType type)
 {
   return GST_URI_SRC;
 }
@@ -145,19 +145,19 @@ _host_fixup (const gchar *host)
 }
 
 /*
- * _enhancer_check_for_uri:
- * @self: a #ClapperEnhancerSrc
+ * _extractable_check_for_uri:
+ * @self: a #ClapperExtractableSrc
  * @uri: a #GUri
  *
- * Check whether there is at least one enhancer for @uri in global list.
+ * Check whether there is at least one extractable enhancer for @uri in global list.
  * This is used to reject URI early, thus making playbin choose different
  * source element. It uses global list, since at this stage element is not
  * yet placed within pipeline, so it cannot get proxies from player.
  *
- * Returns: whether at least one enhancer advertises support for given URI.
+ * Returns: whether at least one extractable enhancer advertises support for given URI.
  */
 static gboolean
-_enhancer_check_for_uri (ClapperEnhancerSrc *self, GUri *uri)
+_extractable_check_for_uri (ClapperExtractableSrc *self, GUri *uri)
 {
   ClapperEnhancerProxyList *proxies = clapper_get_global_enhancer_proxies ();
   gboolean is_https;
@@ -168,7 +168,7 @@ _enhancer_check_for_uri (ClapperEnhancerSrc *self, GUri *uri)
   if (host)
     host = _host_fixup (host);
 
-  GST_INFO_OBJECT (self, "Enhancer check, scheme: \"%s\", host: \"%s\"",
+  GST_INFO_OBJECT (self, "Extractable check, scheme: \"%s\", host: \"%s\"",
       scheme, GST_STR_NULL (host));
 
   /* Whether "http(s)" scheme is used */
@@ -191,8 +191,8 @@ _enhancer_check_for_uri (ClapperEnhancerSrc *self, GUri *uri)
 }
 
 /*
- * _filter_enhancers_for_uri:
- * @self: a #ClapperEnhancerSrc
+ * _filter_extractables_for_uri:
+ * @self: a #ClapperExtractableSrc
  * @proxies: a #ClapperEnhancerProxyList
  * @uri: a #GUri
  *
@@ -202,7 +202,7 @@ _enhancer_check_for_uri (ClapperEnhancerSrc *self, GUri *uri)
  * Returns: (transfer full): A sublist in the form of #GList with proxies.
  */
 static GList *
-_filter_enhancers_for_uri (ClapperEnhancerSrc *self,
+_filter_extractables_for_uri (ClapperExtractableSrc *self,
     ClapperEnhancerProxyList *proxies, GUri *uri)
 {
   GList *sublist = NULL;
@@ -214,7 +214,7 @@ _filter_enhancers_for_uri (ClapperEnhancerSrc *self,
   if (host)
     host = _host_fixup (host);
 
-  GST_INFO_OBJECT (self, "Enhancer filter, scheme: \"%s\", host: \"%s\"",
+  GST_INFO_OBJECT (self, "Extractable filter, scheme: \"%s\", host: \"%s\"",
       scheme, GST_STR_NULL (host));
 
   /* Whether "http(s)" scheme is used */
@@ -239,7 +239,7 @@ _filter_enhancers_for_uri (ClapperEnhancerSrc *self,
 }
 
 static const gchar *const *
-clapper_enhancer_src_uri_handler_get_protocols (GType type)
+clapper_extractable_src_uri_handler_get_protocols (GType type)
 {
   static GOnce schemes_once = G_ONCE_INIT;
 
@@ -248,9 +248,9 @@ clapper_enhancer_src_uri_handler_get_protocols (GType type)
 }
 
 static gchar *
-clapper_enhancer_src_uri_handler_get_uri (GstURIHandler *handler)
+clapper_extractable_src_uri_handler_get_uri (GstURIHandler *handler)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (handler);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (handler);
   gchar *uri;
 
   GST_OBJECT_LOCK (self);
@@ -261,10 +261,10 @@ clapper_enhancer_src_uri_handler_get_uri (GstURIHandler *handler)
 }
 
 static gboolean
-clapper_enhancer_src_uri_handler_set_uri (GstURIHandler *handler,
+clapper_extractable_src_uri_handler_set_uri (GstURIHandler *handler,
     const gchar *uri, GError **error)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (handler);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (handler);
   GUri *guri;
   const gchar *const *protocols;
   gboolean supported = FALSE;
@@ -300,7 +300,7 @@ clapper_enhancer_src_uri_handler_set_uri (GstURIHandler *handler,
     return FALSE;
   }
 
-  if (!_enhancer_check_for_uri (self, guri)) {
+  if (!_extractable_check_for_uri (self, guri)) {
     g_set_error (error, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
         "None of the available enhancers can handle this URI");
     g_uri_unref (guri);
@@ -324,22 +324,22 @@ clapper_enhancer_src_uri_handler_set_uri (GstURIHandler *handler,
 static void
 _uri_handler_iface_init (GstURIHandlerInterface *iface)
 {
-  iface->get_type = clapper_enhancer_src_uri_handler_get_type;
-  iface->get_protocols = clapper_enhancer_src_uri_handler_get_protocols;
-  iface->get_uri = clapper_enhancer_src_uri_handler_get_uri;
-  iface->set_uri = clapper_enhancer_src_uri_handler_set_uri;
+  iface->get_type = clapper_extractable_src_uri_handler_get_type;
+  iface->get_protocols = clapper_extractable_src_uri_handler_get_protocols;
+  iface->get_uri = clapper_extractable_src_uri_handler_get_uri;
+  iface->set_uri = clapper_extractable_src_uri_handler_set_uri;
 }
 
-#define parent_class clapper_enhancer_src_parent_class
-G_DEFINE_TYPE_WITH_CODE (ClapperEnhancerSrc, clapper_enhancer_src, GST_TYPE_PUSH_SRC,
+#define parent_class clapper_extractable_src_parent_class
+G_DEFINE_TYPE_WITH_CODE (ClapperExtractableSrc, clapper_extractable_src, GST_TYPE_PUSH_SRC,
     G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, _uri_handler_iface_init));
-GST_ELEMENT_REGISTER_DEFINE (clapperenhancersrc, "clapperenhancersrc",
-    512, CLAPPER_TYPE_ENHANCER_SRC);
+GST_ELEMENT_REGISTER_DEFINE (clapperextractablesrc, "clapperextractablesrc",
+    512, CLAPPER_TYPE_EXTRACTABLE_SRC);
 
 static gboolean
-clapper_enhancer_src_start (GstBaseSrc *base_src)
+clapper_extractable_src_start (GstBaseSrc *base_src)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (base_src);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (base_src);
   gboolean can_start;
 
   GST_DEBUG_OBJECT (self, "Start");
@@ -358,9 +358,9 @@ clapper_enhancer_src_start (GstBaseSrc *base_src)
 }
 
 static gboolean
-clapper_enhancer_src_stop (GstBaseSrc *base_src)
+clapper_extractable_src_stop (GstBaseSrc *base_src)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (base_src);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (base_src);
 
   GST_DEBUG_OBJECT (self, "Stop");
 
@@ -370,9 +370,9 @@ clapper_enhancer_src_stop (GstBaseSrc *base_src)
 }
 
 static gboolean
-clapper_enhancer_src_get_size (GstBaseSrc *base_src, guint64 *size)
+clapper_extractable_src_get_size (GstBaseSrc *base_src, guint64 *size)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (base_src);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (base_src);
 
   if (self->buf_size > 0) {
     *size = self->buf_size;
@@ -383,15 +383,15 @@ clapper_enhancer_src_get_size (GstBaseSrc *base_src, guint64 *size)
 }
 
 static gboolean
-clapper_enhancer_src_is_seekable (GstBaseSrc *base_src)
+clapper_extractable_src_is_seekable (GstBaseSrc *base_src)
 {
   return FALSE;
 }
 
 static gboolean
-clapper_enhancer_src_unlock (GstBaseSrc *base_src)
+clapper_extractable_src_unlock (GstBaseSrc *base_src)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (base_src);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (base_src);
 
   GST_LOG_OBJECT (self, "Cancel triggered");
   g_cancellable_cancel (self->cancellable);
@@ -400,9 +400,9 @@ clapper_enhancer_src_unlock (GstBaseSrc *base_src)
 }
 
 static gboolean
-clapper_enhancer_src_unlock_stop (GstBaseSrc *base_src)
+clapper_extractable_src_unlock_stop (GstBaseSrc *base_src)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (base_src);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (base_src);
 
   GST_LOG_OBJECT (self, "Resetting cancellable");
 
@@ -414,7 +414,7 @@ clapper_enhancer_src_unlock_stop (GstBaseSrc *base_src)
 
 /* Pushes tags, toc and request headers downstream (all transfer full) */
 static void
-_push_events (ClapperEnhancerSrc *self, GstTagList *tags, GstToc *toc,
+_push_events (ClapperExtractableSrc *self, GstTagList *tags, GstToc *toc,
     GstStructure *headers, gboolean updated)
 {
   GstEvent *event;
@@ -462,9 +462,9 @@ _push_events (ClapperEnhancerSrc *self, GstTagList *tags, GstToc *toc,
 }
 
 static GstFlowReturn
-clapper_enhancer_src_create (GstPushSrc *push_src, GstBuffer **outbuf)
+clapper_extractable_src_create (GstPushSrc *push_src, GstBuffer **outbuf)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (push_src);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (push_src);
   ClapperEnhancerProxyList *proxies;
   GList *filtered_proxies;
   GUri *guri;
@@ -502,7 +502,7 @@ clapper_enhancer_src_create (GstPushSrc *push_src, GstBuffer **outbuf)
 
   GST_OBJECT_UNLOCK (self);
 
-  filtered_proxies = _filter_enhancers_for_uri (self, proxies, guri);
+  filtered_proxies = _filter_extractables_for_uri (self, proxies, guri);
   gst_object_unref (proxies);
 
   harvest = clapper_enhancer_director_extract (self->director,
@@ -554,7 +554,7 @@ _handle_uri_query (GstQuery *query)
 }
 
 static gboolean
-clapper_enhancer_src_query (GstBaseSrc *base_src, GstQuery *query)
+clapper_extractable_src_query (GstBaseSrc *base_src, GstQuery *query)
 {
   gboolean ret = FALSE;
 
@@ -573,7 +573,7 @@ clapper_enhancer_src_query (GstBaseSrc *base_src, GstQuery *query)
 }
 
 static void
-clapper_enhancer_src_set_enhancer_proxies (ClapperEnhancerSrc *self,
+clapper_extractable_src_set_enhancer_proxies (ClapperExtractableSrc *self,
     ClapperEnhancerProxyList *enhancer_proxies)
 {
   GST_OBJECT_LOCK (self);
@@ -583,15 +583,15 @@ clapper_enhancer_src_set_enhancer_proxies (ClapperEnhancerSrc *self,
 }
 
 static void
-clapper_enhancer_src_init (ClapperEnhancerSrc *self)
+clapper_extractable_src_init (ClapperExtractableSrc *self)
 {
   self->cancellable = g_cancellable_new ();
 }
 
 static void
-clapper_enhancer_src_dispose (GObject *object)
+clapper_extractable_src_dispose (GObject *object)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (object);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (object);
 
   GST_OBJECT_LOCK (self);
   g_clear_object (&self->director);
@@ -601,9 +601,9 @@ clapper_enhancer_src_dispose (GObject *object)
 }
 
 static void
-clapper_enhancer_src_finalize (GObject *object)
+clapper_extractable_src_finalize (GObject *object)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (object);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (object);
 
   GST_TRACE_OBJECT (self, "Finalize");
 
@@ -616,10 +616,10 @@ clapper_enhancer_src_finalize (GObject *object)
 }
 
 static void
-clapper_enhancer_src_set_property (GObject *object, guint prop_id,
+clapper_extractable_src_set_property (GObject *object, guint prop_id,
     const GValue *value, GParamSpec *pspec)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (object);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (object);
 
   switch (prop_id) {
     case PROP_URI:{
@@ -632,7 +632,7 @@ clapper_enhancer_src_set_property (GObject *object, guint prop_id,
       break;
     }
     case PROP_ENHANCER_PROXIES:
-      clapper_enhancer_src_set_enhancer_proxies (self, g_value_get_object (value));
+      clapper_extractable_src_set_enhancer_proxies (self, g_value_get_object (value));
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -641,10 +641,10 @@ clapper_enhancer_src_set_property (GObject *object, guint prop_id,
 }
 
 static void
-clapper_enhancer_src_get_property (GObject *object, guint prop_id,
+clapper_extractable_src_get_property (GObject *object, guint prop_id,
     GValue *value, GParamSpec *pspec)
 {
-  ClapperEnhancerSrc *self = CLAPPER_ENHANCER_SRC_CAST (object);
+  ClapperExtractableSrc *self = CLAPPER_EXTRACTABLE_SRC_CAST (object);
 
   switch (prop_id) {
     case PROP_URI:
@@ -657,30 +657,30 @@ clapper_enhancer_src_get_property (GObject *object, guint prop_id,
 }
 
 static void
-clapper_enhancer_src_class_init (ClapperEnhancerSrcClass *klass)
+clapper_extractable_src_class_init (ClapperExtractableSrcClass *klass)
 {
   GObjectClass *gobject_class = (GObjectClass *) klass;
   GstElementClass *gstelement_class = (GstElementClass *) klass;
   GstBaseSrcClass *gstbasesrc_class = (GstBaseSrcClass *) klass;
   GstPushSrcClass *gstpushsrc_class = (GstPushSrcClass *) klass;
 
-  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperenhancersrc", 0,
-      "Clapper Enhancer Source");
+  GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperextractablesrc", 0,
+      "Clapper Extractable Source");
 
-  gobject_class->set_property = clapper_enhancer_src_set_property;
-  gobject_class->get_property = clapper_enhancer_src_get_property;
-  gobject_class->dispose = clapper_enhancer_src_dispose;
-  gobject_class->finalize = clapper_enhancer_src_finalize;
+  gobject_class->set_property = clapper_extractable_src_set_property;
+  gobject_class->get_property = clapper_extractable_src_get_property;
+  gobject_class->dispose = clapper_extractable_src_dispose;
+  gobject_class->finalize = clapper_extractable_src_finalize;
 
-  gstbasesrc_class->start = clapper_enhancer_src_start;
-  gstbasesrc_class->stop = clapper_enhancer_src_stop;
-  gstbasesrc_class->get_size = clapper_enhancer_src_get_size;
-  gstbasesrc_class->is_seekable = clapper_enhancer_src_is_seekable;
-  gstbasesrc_class->unlock = clapper_enhancer_src_unlock;
-  gstbasesrc_class->unlock_stop = clapper_enhancer_src_unlock_stop;
-  gstbasesrc_class->query = clapper_enhancer_src_query;
+  gstbasesrc_class->start = clapper_extractable_src_start;
+  gstbasesrc_class->stop = clapper_extractable_src_stop;
+  gstbasesrc_class->get_size = clapper_extractable_src_get_size;
+  gstbasesrc_class->is_seekable = clapper_extractable_src_is_seekable;
+  gstbasesrc_class->unlock = clapper_extractable_src_unlock;
+  gstbasesrc_class->unlock_stop = clapper_extractable_src_unlock_stop;
+  gstbasesrc_class->query = clapper_extractable_src_query;
 
-  gstpushsrc_class->create = clapper_enhancer_src_create;
+  gstpushsrc_class->create = clapper_extractable_src_create;
 
   param_specs[PROP_URI] = g_param_spec_string ("uri",
       "URI", "URI", NULL,
@@ -694,7 +694,7 @@ clapper_enhancer_src_class_init (ClapperEnhancerSrcClass *klass)
 
   gst_element_class_add_static_pad_template (gstelement_class, &src_template);
 
-  gst_element_class_set_static_metadata (gstelement_class, "Clapper Enhancer Source",
-      "Source", "A source element that uses Clapper Enhancers to produce data",
+  gst_element_class_set_static_metadata (gstelement_class, "Clapper Extractable Source",
+      "Source", "A source element that uses Clapper extractable enhancers to produce data",
       "Rafał Dzięgiel <rafostar.github@gmail.com>");
 }

src/lib/clapper/gst/clapper-plugin.c

@@ -27,7 +27,7 @@
 #include "../clapper-extractable.h"
 
 #include "clapper-plugin-private.h"
-#include "clapper-enhancer-src-private.h"
+#include "clapper-extractable-src-private.h"
 #include "clapper-uri-list-demux-private.h"
 
 /*
@@ -67,7 +67,7 @@ clapper_gst_plugin_init (GstPlugin *plugin)
 
   /* Avoid registering an URI handler without schemes */
   if (clapper_gst_plugin_has_enhancers (global_proxies, CLAPPER_TYPE_EXTRACTABLE))
-    res |= GST_ELEMENT_REGISTER (clapperenhancersrc, plugin);
+    res |= GST_ELEMENT_REGISTER (clapperextractablesrc, plugin);
 
   res |= GST_ELEMENT_REGISTER (clapperurilistdemux, plugin);
 

src/lib/clapper/gst/clapper-uri-list-demux.c

@@ -193,7 +193,7 @@ _feature_filter (GstPluginFeature *feature, const gchar *search_proto)
   feature_name = gst_plugin_feature_get_name (feature);
 
   /* Do not loop endlessly creating our own sources and demuxers */
-  if (!feature_name || strcmp (feature_name, "clapperenhancersrc") == 0)
+  if (!feature_name || strcmp (feature_name, "clapperextractablesrc") == 0)
     return FALSE;
 
   protocols = gst_element_factory_get_uri_protocols (factory);

src/lib/clapper/meson.build

@@ -55,7 +55,6 @@ config_h.set_quoted('PACKAGE_ORIGIN', 'https://github.com/Rafostar/clapper')
 config_h.set_quoted('PLUGIN_DESC', 'Clapper elements')
 config_h.set_quoted('PLUGIN_LICENSE', 'LGPL')
 config_h.set_quoted('CLAPPER_API_NAME', clapper_api_name)
-config_h.set_quoted('CLAPPER_ENHANCERS_ID', 'com.github.rafostar.Clapper.Enhancers')
 config_h.set_quoted('CLAPPER_ENHANCERS_PATH', clapper_enhancers_dir)
 
 configure_file(
@@ -156,7 +155,7 @@ clapper_sources = [
   'clapper-utils.c',
   'clapper-video-stream.c',
   'gst/clapper-plugin.c',
-  'gst/clapper-enhancer-src.c',
+  'gst/clapper-extractable-src.c',
   'gst/clapper-enhancer-director.c',
   'gst/clapper-uri-list-demux.c',
   '../shared/clapper-shared-utils.c',

src/lib/clapper/metadata/Clapper-0.0.metadata

@@ -1,6 +1,6 @@
 // Skipped by GI, but Vala can handle it fine
-//init_get_option_group skip=false
 *_FORMAT skip=false
+*.peek_* skip=false
 
 // Init func compatibility
 init.argv unowned

src/lib/gst/plugin/gstclappersink.c

@@ -594,11 +594,14 @@ static gboolean
 gst_clapper_sink_start (GstBaseSink *bsink)
 {
   GstClapperSink *self = GST_CLAPPER_SINK_CAST (bsink);
+  gboolean with_clapper_gtk;
 
   GST_INFO_OBJECT (self, "Start");
 
-  if (G_UNLIKELY (!(! !gst_gtk_invoke_on_main ((GThreadFunc) (GCallback)
-      gst_clapper_sink_start_on_main, self)))) {
+  with_clapper_gtk = g_type_from_name ("ClapperGtkVideo");
+
+  if (G_UNLIKELY (!with_clapper_gtk && !(! !gst_gtk_invoke_on_main (
+      (GThreadFunc) (GCallback) gst_clapper_sink_start_on_main, self)))) {
     GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
         ("GtkWidget could not be created"), (NULL));
 

src/lib/meson.build

@@ -5,7 +5,8 @@ vapigen = find_program('vapigen', required: get_option('vapi'))
 build_vapi = (vapigen.found() and not get_option('vapi').disabled())
 
 gir_init_section = '--add-init-section=extern void gst_init(gint*,gchar**);' + \
-  'g_setenv("GST_REGISTRY_1.0", "@0@", TRUE);'.format(meson.current_build_dir() + '/gir_empty_registry.reg') + \
+  'g_setenv("GST_REGISTRY_DISABLE", "yes", TRUE);' + \
+  'g_setenv("GST_REGISTRY_1_0", "@0@", TRUE);'.format(meson.current_build_dir() + '/gir_empty_registry.reg') + \
   'g_setenv("GST_PLUGIN_PATH_1_0", "", TRUE);' + \
   'g_setenv("GST_PLUGIN_SYSTEM_PATH_1_0", "", TRUE);' + \
   'gst_init(NULL,NULL);'

src/lib/shared/clapper-api-visibility.h.in

@@ -41,5 +41,11 @@
 #endif
 
 #define @CLAPPER_API@_API                _@CLAPPER_API@_VISIBILITY
+
+#if !defined(@CLAPPER_API@_COMPILATION)
 #define @CLAPPER_API@_DEPRECATED         G_DEPRECATED _@CLAPPER_API@_VISIBILITY
 #define @CLAPPER_API@_DEPRECATED_FOR(f)  G_DEPRECATED_FOR(f) _@CLAPPER_API@_VISIBILITY
+#else
+#define @CLAPPER_API@_DEPRECATED         _@CLAPPER_API@_VISIBILITY
+#define @CLAPPER_API@_DEPRECATED_FOR(f)  _@CLAPPER_API@_VISIBILITY
+#endif