gst/gstpreset.c

   1 /* GStreamer
   2  * Copyright (C) 2006 Stefan Kost <ensonic@users.sf.net>
   3  *
   4  * gstpreset.c: helper interface for element presets
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21 /**
  22  * SECTION:gstpreset
  23  * @short_description: helper interface for element presets
  24  *
  25  * This interface offers methods to query and manipulate parameter preset sets.
  26  * A preset is a bunch of property settings, together with meta data and a name.
  27  * The name of a preset serves as key for subsequent method calls to manipulate
  28  * single presets.
  29  * All instances of one type will share the list of presets. The list is created
  30  * on demand, if presets are not used, the list is not created.
  31  *
  32  * The interface comes with a default implementation that serves most plugins.
  33  * Wrapper plugins will override most methods to implement support for the
  34  * native preset format of those wrapped plugins.
  35  * One method that is useful to be overridden is gst_preset_get_property_names().
  36  * With that one can control which properties are saved and in which order.
  37  * When implementing support for read-only presets, one should set the vmethods
  38  * for gst_preset_save_preset() and gst_preset_delete_preset() to %NULL.
  39  * Applications can use gst_preset_is_editable() to check for that.
  40  *
  41  * The default implementation supports presets located in a system directory,
  42  * application specific directory and in the users home directory. When getting
  43  * a list of presets individual presets are read and overlaid in 1) system,
  44  * 2) application and 3) user order. Whenever an earlier entry is newer, the
  45  * later entries will be updated. Since 1.8 you can also provide extra paths
  46  * where to find presets through the GST_PRESET_PATH environment variable.
  47  * Presets found in those paths will be concidered as "app presets".
  48  */
  49 /* FIXME:
  50  * - non racyness
  51  *   - we need to avoid two instances writing the preset file
  52  *     -> flock(fileno()), http://www.ecst.csuchico.edu/~beej/guide/ipc/flock.html
  53  *     -> open exclusive
  54  *     -> better save the new file to a tempfile and then rename?
  55  *   - we like to know when any other instance makes changes to the keyfile
  56  *     - then ui can be updated
  57  *     - and we make sure that we don't lose edits
  58  *   -> its the same problem actually, once for inside a process, once system-
  59  *      wide
  60  *     - can we use a lock inside a names shared memory segment?
  61  *
  62  * - should there be a 'preset-list' property to get the preset list
  63  *   (and to connect a notify:: to to listen for changes)
  64  *   we could use gnome_vfs_monitor_add() to monitor the user preset_file.
  65  *
  66  * - should there be a 'preset-name' property so that we can set a preset via
  67  *   gst-launch, or should we handle this with special syntax in gst-launch:
  68  *   gst-launch element preset:<preset-name> property=value ...
  69  *   - this would allow to have preset-bundles too (a preset on bins that
  70  *     specifies presets for children
  71  */
  72
  73 #include "gst_private.h"
  74
  75 #include "gstpreset.h"
  76 #include "gstchildproxy.h"
  77 #include "gstinfo.h"
  78 #include "gstvalue.h"
  79
  80 #ifdef HAVE_UNISTD_H
  81 #include <unistd.h>
  82 #endif
  83 #include <glib/gstdio.h>
  84
  85 #ifdef G_OS_WIN32
  86 #define WIN32_LEAN_AND_MEAN
  87 #include <windows.h>
  88
  89 extern HMODULE _priv_gst_dll_handle;
  90 #endif
  91
  92 #define GST_CAT_DEFAULT preset_debug
  93 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
  94
  95 /* defines for keyfile usage, this group contains the element type name and
  96  * version these presets belong to. */
  97 #define PRESET_HEADER "_presets_"
  98
  99 /* keys of the preset header section */
 100 #define PRESET_HEADER_ELEMENT_NAME "element-name"
 101 #define PRESET_HEADER_VERSION "version"
 102
 103 static GQuark preset_user_path_quark = 0;
 104 static GQuark preset_app_path_quark = 0;
 105 static GQuark preset_system_path_quark = 0;
 106 static GQuark preset_quark = 0;
 107
 108 /* the application can set a custom path that is checked in addition to standard
 109  * system and user dirs. This helps to develop new presets first local to the
 110  * application.
 111  */
 112 static gchar *preset_app_dir = NULL;
 113
 114 /* default iface implementation */
 115
 116 static gboolean gst_preset_default_save_presets_file (GstPreset * preset);
 117
 118 /*
 119  * preset_get_paths:
 120  * @preset: a #GObject that implements #GstPreset
 121  * @preset_user_path: (out) (allow-none): location for path or %NULL
 122  * @preset_app_path: (out) (allow-none): location for path or %NULL
 123  * @preset_system_path: (out) (allow-none): location for path or %NULL
 124  *
 125  * Fetch the preset_path for user local, application specific and system wide
 126  * settings. Don't free after use.
 127  *
 128  * Returns: %FALSE if no paths could be found.
 129  */
 130 static gboolean
 131 preset_get_paths (GstPreset * preset, const gchar ** preset_user_path,
 132     const gchar ** preset_app_path, const gchar ** preset_system_path)
 133 {
 134   GType type = G_TYPE_FROM_INSTANCE (preset);
 135   gchar *preset_path;
 136   const gchar *element_name;
 137
 138   /* we use the element name when we must construct the paths */
 139   element_name = G_OBJECT_TYPE_NAME (preset);
 140   GST_INFO_OBJECT (preset, "element_name: '%s'", element_name);
 141
 142   if (preset_user_path) {
 143     /* preset user path requested, see if we have it cached in the qdata */
 144     if (!(preset_path = g_type_get_qdata (type, preset_user_path_quark))) {
 145       gchar *preset_dir;
 146
 147       /* user presets go in  user's XDG data directory. */
 148       preset_dir = g_build_filename (g_get_user_data_dir (),
 149           "gstreamer-" GST_API_VERSION, "presets", NULL);
 150       GST_INFO_OBJECT (preset, "user_preset_dir: '%s'", preset_dir);
 151       preset_path =
 152           g_strdup_printf ("%s" G_DIR_SEPARATOR_S "%s.prs", preset_dir,
 153           element_name);
 154       GST_INFO_OBJECT (preset, "user_preset_path: '%s'", preset_path);
 155       /* create dirs */
 156       g_mkdir_with_parents (preset_dir, 0755);
 157       g_free (preset_dir);
 158
 159       /* cache the preset path to the type */
 160       g_type_set_qdata (type, preset_user_path_quark, preset_path);
 161     }
 162     *preset_user_path = preset_path;
 163   }
 164
 165   if (preset_app_path) {
 166     if (preset_app_dir) {
 167       if (!(preset_path = g_type_get_qdata (type, preset_system_path_quark))) {
 168         preset_path = g_strdup_printf ("%s" G_DIR_SEPARATOR_S "%s.prs",
 169             preset_app_dir, element_name);
 170         GST_INFO_OBJECT (preset, "application_preset_path: '%s'", preset_path);
 171
 172         /* cache the preset path to the type */
 173         g_type_set_qdata (type, preset_app_path_quark, preset_path);
 174       }
 175       *preset_app_path = preset_path;
 176     } else {
 177       *preset_app_path = NULL;
 178     }
 179   }
 180
 181   if (preset_system_path) {
 182     /* preset system path requested, see if we have it cached in the qdata */
 183     if (!(preset_path = g_type_get_qdata (type, preset_system_path_quark))) {
 184       gchar *preset_dir;
 185
 186       /* system presets in '$GST_DATADIR/gstreamer-1.0/presets/GstAudioPanorama.prs' */
 187 #ifdef G_OS_WIN32
 188       gchar *basedir =
 189           g_win32_get_package_installation_directory_of_module
 190           (_priv_gst_dll_handle);
 191       preset_dir =
 192           g_build_filename (basedir, "share", "gstreamer-" GST_API_VERSION,
 193           "presets", NULL);
 194       g_free (basedir);
 195 #else
 196       preset_dir = g_build_filename (GST_DATADIR, "gstreamer-" GST_API_VERSION,
 197           "presets", NULL);
 198 #endif
 199       GST_INFO_OBJECT (preset, "system_preset_dir: '%s'", preset_dir);
 200       preset_path = g_strdup_printf ("%s" G_DIR_SEPARATOR_S "%s.prs",
 201           preset_dir, element_name);
 202       GST_INFO_OBJECT (preset, "system_preset_path: '%s'", preset_path);
 203       /* create dirs */
 204       g_mkdir_with_parents (preset_dir, 0755);
 205       g_free (preset_dir);
 206
 207       /* cache the preset path to the type */
 208       g_type_set_qdata (type, preset_system_path_quark, preset_path);
 209     }
 210     *preset_system_path = preset_path;
 211   }
 212   return TRUE;
 213 }
 214
 215 static gboolean
 216 preset_skip_property (GParamSpec * property)
 217 {
 218   if (((property->flags & G_PARAM_READWRITE) != G_PARAM_READWRITE) ||
 219       (property->flags & G_PARAM_CONSTRUCT_ONLY))
 220     return TRUE;
 221   /* FIXME: skip GST_PARAM_NOT_PRESETABLE, see #522205 */
 222   return FALSE;
 223 }
 224
 225 static guint64
 226 preset_parse_version (const gchar * str_version)
 227 {
 228   guint major, minor, micro, nano;
 229   gint num;
 230
 231   major = minor = micro = nano = 0;
 232
 233   /* parse version (e.g. 0.10.15.1) to guint64 */
 234   num = sscanf (str_version, "%u.%u.%u.%u", &major, &minor, &micro, &nano);
 235   /* make sure we have at least "major.minor" */
 236   if (num > 1) {
 237     guint64 version;
 238
 239     version = ((((major << 8 | minor) << 8) | micro) << 8) | nano;
 240     GST_DEBUG ("version %s -> %" G_GUINT64_FORMAT, str_version, version);
 241     return version;
 242   }
 243   return G_GUINT64_CONSTANT (0);
 244 }
 245
 246 static GKeyFile *
 247 preset_open_and_parse_header (GstPreset * preset, const gchar * preset_path,
 248     guint64 * preset_version)
 249 {
 250   GKeyFile *in;
 251   GError *error = NULL;
 252   gboolean res;
 253   const gchar *element_name;
 254   gchar *name;
 255
 256   in = g_key_file_new ();
 257
 258   res = g_key_file_load_from_file (in, preset_path,
 259       G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error);
 260   if (!res || error != NULL)
 261     goto load_error;
 262
 263   /* element type name and preset name must match or we are dealing with a wrong
 264    * preset file */
 265   element_name = G_OBJECT_TYPE_NAME (preset);
 266   name =
 267       g_key_file_get_value (in, PRESET_HEADER, PRESET_HEADER_ELEMENT_NAME,
 268       NULL);
 269
 270   if (!name || strcmp (name, element_name))
 271     goto wrong_name;
 272
 273   g_free (name);
 274
 275   /* get the version now so that the caller can check it */
 276   if (preset_version) {
 277     gchar *str =
 278         g_key_file_get_value (in, PRESET_HEADER, PRESET_HEADER_VERSION, NULL);
 279     *preset_version = preset_parse_version (str);
 280     g_free (str);
 281   }
 282
 283   return in;
 284
 285   /* ERRORS */
 286 load_error:
 287   {
 288     GST_WARNING_OBJECT (preset, "Unable to read preset file %s: %s",
 289         preset_path, error->message);
 290     g_error_free (error);
 291     g_key_file_free (in);
 292     return NULL;
 293   }
 294 wrong_name:
 295   {
 296     GST_WARNING_OBJECT (preset,
 297         "Wrong element name in preset file %s. Expected %s, got %s",
 298         preset_path, element_name, GST_STR_NULL (name));
 299     g_free (name);
 300     g_key_file_free (in);
 301     return NULL;
 302   }
 303 }
 304
 305 static void
 306 preset_merge (GKeyFile * system, GKeyFile * user)
 307 {
 308   gchar *str;
 309   gchar **groups, **keys;
 310   gsize i, j, num_groups, num_keys;
 311
 312   /* copy file comment if there is any */
 313   if ((str = g_key_file_get_comment (user, NULL, NULL, NULL))) {
 314     g_key_file_set_comment (system, NULL, NULL, str, NULL);
 315     g_free (str);
 316   }
 317
 318   /* get groups in user and copy into system */
 319   groups = g_key_file_get_groups (user, &num_groups);
 320   for (i = 0; i < num_groups; i++) {
 321     /* copy group comment if there is any */
 322     if ((str = g_key_file_get_comment (user, groups[i], NULL, NULL))) {
 323       g_key_file_set_comment (system, groups[i], NULL, str, NULL);
 324       g_free (str);
 325     }
 326
 327     /* ignore private groups */
 328     if (groups[i][0] == '_')
 329       continue;
 330
 331     /* if group already exists in system, remove and re-add keys from user */
 332     if (g_key_file_has_group (system, groups[i])) {
 333       g_key_file_remove_group (system, groups[i], NULL);
 334     }
 335
 336     keys = g_key_file_get_keys (user, groups[i], &num_keys, NULL);
 337     for (j = 0; j < num_keys; j++) {
 338       /* copy key comment if there is any */
 339       if ((str = g_key_file_get_comment (user, groups[i], keys[j], NULL))) {
 340         g_key_file_set_comment (system, groups[i], keys[j], str, NULL);
 341         g_free (str);
 342       }
 343       str = g_key_file_get_value (user, groups[i], keys[j], NULL);
 344       g_key_file_set_value (system, groups[i], keys[j], str);
 345       g_free (str);
 346     }
 347     g_strfreev (keys);
 348   }
 349   g_strfreev (groups);
 350 }
 351
 352 /* reads the user and system presets files and merges them together. This
 353  * function caches the GKeyFile on the element type. If there is no existing
 354  * preset file, a new in-memory GKeyFile will be created. */
 355 static GKeyFile *
 356 preset_get_keyfile (GstPreset * preset)
 357 {
 358   GKeyFile *presets;
 359   GType type = G_TYPE_FROM_INSTANCE (preset);
 360
 361   /* first see if the have a cached version for the type */
 362   if (!(presets = g_type_get_qdata (type, preset_quark))) {
 363     const gchar *preset_user_path, *preset_app_path, *preset_system_path;
 364     guint64 version_system = G_GUINT64_CONSTANT (0);
 365     guint64 version_app = G_GUINT64_CONSTANT (0);
 366     guint64 version_user = G_GUINT64_CONSTANT (0);
 367     guint64 version = G_GUINT64_CONSTANT (0);
 368     gboolean merged = FALSE;
 369     GKeyFile *in_user = NULL, *in_app = NULL, *in_system;
 370
 371     const gchar *envvar;
 372
 373     /* try to load the user, app and system presets, we do this to get the
 374      * versions of all files. */
 375     envvar = g_getenv ("GST_PRESET_PATH");
 376     if (envvar) {
 377       gint i;
 378       gchar **preset_dirs = g_strsplit (envvar, G_SEARCHPATH_SEPARATOR_S, -1);
 379
 380       for (i = 0; preset_dirs[i]; i++) {
 381         gchar *preset_path = g_strdup_printf ("%s" G_DIR_SEPARATOR_S "%s.prs",
 382             preset_dirs[i], G_OBJECT_TYPE_NAME (preset));
 383
 384         in_user = preset_open_and_parse_header (preset, preset_path,
 385             &version_user);
 386         g_free (preset_path);
 387         if (in_user)
 388           break;
 389       }
 390       g_strfreev (preset_dirs);
 391     }
 392
 393     preset_get_paths (preset, &preset_user_path, &preset_app_path,
 394         &preset_system_path);
 395     if (!in_user) {
 396       in_user = preset_open_and_parse_header (preset, preset_user_path,
 397           &version_user);
 398     }
 399
 400     if (preset_app_path) {
 401       in_app = preset_open_and_parse_header (preset, preset_app_path,
 402           &version_app);
 403     }
 404     in_system = preset_open_and_parse_header (preset, preset_system_path,
 405         &version_system);
 406
 407     /* compare version to check for merge */
 408     if (in_system) {
 409       presets = in_system;
 410       version = version_system;
 411     }
 412     if (in_app) {
 413       /* if system version is higher, merge */
 414       if (version > version_app) {
 415         preset_merge (presets, in_app);
 416         g_key_file_free (in_app);
 417       } else {
 418         if (presets)
 419           g_key_file_free (presets);
 420         presets = in_app;
 421         version = version_app;
 422       }
 423     }
 424     if (in_user) {
 425       /* if system or app version is higher, merge */
 426       if (version > version_user) {
 427         preset_merge (presets, in_user);
 428         g_key_file_free (in_user);
 429         merged = TRUE;
 430       } else {
 431         if (presets)
 432           g_key_file_free (presets);
 433         presets = in_user;
 434       }
 435     }
 436
 437     if (!presets) {
 438       /* we did not load a user, app or system presets file, create a new one */
 439       presets = g_key_file_new ();
 440       g_key_file_set_string (presets, PRESET_HEADER, PRESET_HEADER_ELEMENT_NAME,
 441           G_OBJECT_TYPE_NAME (preset));
 442     }
 443
 444     /* attach the preset to the type */
 445     g_type_set_qdata (type, preset_quark, (gpointer) presets);
 446
 447     if (merged) {
 448       gst_preset_default_save_presets_file (preset);
 449     }
 450   }
 451   return presets;
 452 }
 453
 454 static gint
 455 compare_strings (gchar ** a, gchar ** b, gpointer user_data)
 456 {
 457   return g_strcmp0 (*a, *b);
 458 }
 459
 460 /* get a list of all supported preset names for an element */
 461 static gchar **
 462 gst_preset_default_get_preset_names (GstPreset * preset)
 463 {
 464   GKeyFile *presets;
 465   gsize i, num_groups;
 466   gchar **groups;
 467
 468   /* get the presets from the type */
 469   if (!(presets = preset_get_keyfile (preset)))
 470     goto no_presets;
 471
 472   /* get the groups, which are also the preset names */
 473   if (!(groups = g_key_file_get_groups (presets, &num_groups)))
 474     goto no_groups;
 475
 476   /* remove all private group names starting with '_' from the array */
 477   for (i = 0; i < num_groups; i++) {
 478     if (groups[i][0] == '_') {
 479       /* free private group */
 480       g_free (groups[i]);
 481       /* move last element of list down */
 482       num_groups--;
 483       /* move last element into removed element */
 484       groups[i] = groups[num_groups];
 485       groups[num_groups] = NULL;
 486     }
 487   }
 488   if (!num_groups) {
 489     GST_INFO_OBJECT (preset, "Empty preset file");
 490     g_strfreev (groups);
 491     return NULL;
 492   }
 493
 494   /* sort the array now */
 495   g_qsort_with_data (groups, num_groups, sizeof (gchar *),
 496       (GCompareDataFunc) compare_strings, NULL);
 497
 498   return groups;
 499
 500   /* ERRORS */
 501 no_presets:
 502   {
 503     GST_WARNING_OBJECT (preset, "Could not load presets");
 504     return NULL;
 505   }
 506 no_groups:
 507   {
 508     GST_WARNING_OBJECT (preset, "Could not find preset groups");
 509     return NULL;
 510   }
 511 }
 512
 513 /* get a list of all property names that are used for presets */
 514 static gchar **
 515 gst_preset_default_get_property_names (GstPreset * preset)
 516 {
 517   GParamSpec **props;
 518   guint i, j = 0, n_props;
 519   GObjectClass *gclass;
 520   gboolean is_child_proxy;
 521   gchar **result = NULL;
 522
 523   gclass = G_OBJECT_CLASS (GST_ELEMENT_GET_CLASS (preset));
 524   is_child_proxy = GST_IS_CHILD_PROXY (preset);
 525
 526   /* get a list of object properties */
 527   props = g_object_class_list_properties (gclass, &n_props);
 528   if (props) {
 529     /* allocate array big enough to hold the worst case, including a terminating
 530      * NULL pointer. */
 531     result = g_new (gchar *, n_props + 1);
 532
 533     /* now filter out the properties that we can use for presets */
 534     GST_DEBUG_OBJECT (preset, "  filtering properties: %u", n_props);
 535     for (i = 0; i < n_props; i++) {
 536       if (preset_skip_property (props[i]))
 537         continue;
 538       GST_DEBUG_OBJECT (preset, "    using: %s", props[i]->name);
 539       result[j++] = g_strdup (props[i]->name);
 540     }
 541     g_free (props);
 542   }
 543
 544   if (is_child_proxy) {
 545     guint c, n_children;
 546     GObject *child;
 547
 548     n_children = gst_child_proxy_get_children_count ((GstChildProxy *) preset);
 549     for (c = 0; c < n_children; c++) {
 550       child = gst_child_proxy_get_child_by_index ((GstChildProxy *) preset, c);
 551       gclass = G_OBJECT_CLASS (GST_ELEMENT_GET_CLASS (child));
 552
 553       props = g_object_class_list_properties (gclass, &n_props);
 554       if (props) {
 555         /* resize property name array */
 556         result = g_renew (gchar *, result, j + n_props + 1);
 557
 558         /* now filter out the properties that we can use for presets */
 559         GST_DEBUG_OBJECT (preset, "  filtering properties: %u", n_props);
 560         for (i = 0; i < n_props; i++) {
 561           if (preset_skip_property (props[i]))
 562             continue;
 563           GST_DEBUG_OBJECT (preset, "    using: %s::%s",
 564               GST_OBJECT_NAME (child), props[i]->name);
 565           result[j++] = g_strdup_printf ("%s::%s", GST_OBJECT_NAME (child),
 566               props[i]->name);
 567         }
 568         g_free (props);
 569       }
 570
 571       g_object_unref (child);
 572     }
 573   }
 574   if (!result) {
 575     GST_INFO_OBJECT (preset, "object has no properties");
 576   } else {
 577     result[j] = NULL;
 578   }
 579   return result;
 580 }
 581
 582 /* load the presets of @name for the instance @preset. Returns %FALSE if something
 583  * failed. */
 584 static gboolean
 585 gst_preset_default_load_preset (GstPreset * preset, const gchar * name)
 586 {
 587   GKeyFile *presets;
 588   gchar **props;
 589   guint i;
 590   GObjectClass *gclass;
 591   gboolean is_child_proxy;
 592
 593   /* get the presets from the type */
 594   if (!(presets = preset_get_keyfile (preset)))
 595     goto no_presets;
 596
 597   /* get the preset name */
 598   if (!g_key_file_has_group (presets, name))
 599     goto no_group;
 600
 601   GST_DEBUG_OBJECT (preset, "loading preset : '%s'", name);
 602
 603   /* get the properties that we can configure in this element */
 604   if (!(props = gst_preset_get_property_names (preset)))
 605     goto no_properties;
 606
 607   gclass = G_OBJECT_CLASS (GST_ELEMENT_GET_CLASS (preset));
 608   is_child_proxy = GST_IS_CHILD_PROXY (preset);
 609
 610   /* for each of the property names, find the preset parameter and try to
 611    * configure the property with its value */
 612   for (i = 0; props[i]; i++) {
 613     gchar *str;
 614     GValue gvalue = { 0, };
 615     GParamSpec *property = NULL;
 616
 617     /* check if we have a settings for this element property */
 618     if (!(str = g_key_file_get_value (presets, name, props[i], NULL))) {
 619       /* the element has a property but the parameter is not in the keyfile */
 620       GST_WARNING_OBJECT (preset, "parameter '%s' not in preset", props[i]);
 621       continue;
 622     }
 623
 624     GST_DEBUG_OBJECT (preset, "setting value '%s' for property '%s'", str,
 625         props[i]);
 626
 627     if (is_child_proxy) {
 628       gst_child_proxy_lookup ((GstChildProxy *) preset, props[i], NULL,
 629           &property);
 630     } else {
 631       property = g_object_class_find_property (gclass, props[i]);
 632     }
 633     if (!property) {
 634       /* the parameter was in the keyfile, the element said it supported it but
 635        * then the property was not found in the element. This should not happen. */
 636       GST_WARNING_OBJECT (preset, "property '%s' not in object", props[i]);
 637       g_free (str);
 638       continue;
 639     }
 640
 641     /* try to deserialize the property value from the keyfile and set it as
 642      * the object property */
 643     g_value_init (&gvalue, property->value_type);
 644     if (gst_value_deserialize (&gvalue, str)) {
 645       if (is_child_proxy) {
 646         gst_child_proxy_set_property ((GstChildProxy *) preset, props[i],
 647             &gvalue);
 648       } else {
 649         g_object_set_property ((GObject *) preset, props[i], &gvalue);
 650       }
 651     } else {
 652       GST_WARNING_OBJECT (preset,
 653           "deserialization of value '%s' for property '%s' failed", str,
 654           props[i]);
 655     }
 656     g_value_unset (&gvalue);
 657     g_free (str);
 658   }
 659   g_strfreev (props);
 660
 661   return TRUE;
 662
 663   /* ERRORS */
 664 no_presets:
 665   {
 666     GST_WARNING_OBJECT (preset, "no presets");
 667     return FALSE;
 668   }
 669 no_group:
 670   {
 671     GST_WARNING_OBJECT (preset, "no preset named '%s'", name);
 672     return FALSE;
 673   }
 674 no_properties:
 675   {
 676     GST_INFO_OBJECT (preset, "no properties");
 677     return FALSE;
 678   }
 679 }
 680
 681 /* save the presets file. A copy of the existing presets file is stored in a
 682  * .bak file */
 683 static gboolean
 684 gst_preset_default_save_presets_file (GstPreset * preset)
 685 {
 686   GKeyFile *presets;
 687   const gchar *preset_path;
 688   GError *error = NULL;
 689   gchar *bak_file_name;
 690   gboolean backup = TRUE;
 691   gchar *data;
 692   gsize data_size;
 693
 694   preset_get_paths (preset, &preset_path, NULL, NULL);
 695
 696   /* get the presets from the type */
 697   if (!(presets = preset_get_keyfile (preset)))
 698     goto no_presets;
 699
 700   GST_DEBUG_OBJECT (preset, "saving preset file: '%s'", preset_path);
 701
 702   /* create backup if possible */
 703   bak_file_name = g_strdup_printf ("%s.bak", preset_path);
 704   if (g_file_test (bak_file_name, G_FILE_TEST_EXISTS)) {
 705     if (g_unlink (bak_file_name)) {
 706       backup = FALSE;
 707       GST_INFO_OBJECT (preset, "cannot remove old backup file : %s",
 708           bak_file_name);
 709     }
 710   }
 711   if (backup) {
 712     if (g_rename (preset_path, bak_file_name)) {
 713       GST_INFO_OBJECT (preset, "cannot backup file : %s -> %s", preset_path,
 714           bak_file_name);
 715     }
 716   }
 717   g_free (bak_file_name);
 718
 719   /* update gstreamer version */
 720   g_key_file_set_string (presets, PRESET_HEADER, PRESET_HEADER_VERSION,
 721       PACKAGE_VERSION);
 722
 723   /* get new contents, wee need this to save it */
 724   if (!(data = g_key_file_to_data (presets, &data_size, &error)))
 725     goto convert_failed;
 726
 727   /* write presets */
 728   if (!g_file_set_contents (preset_path, data, data_size, &error))
 729     goto write_failed;
 730
 731   g_free (data);
 732
 733   return TRUE;
 734
 735   /* ERRORS */
 736 no_presets:
 737   {
 738     GST_WARNING_OBJECT (preset,
 739         "no presets, trying to unlink possibly existing preset file: '%s'",
 740         preset_path);
 741     g_unlink (preset_path);
 742     return FALSE;
 743   }
 744 convert_failed:
 745   {
 746     GST_WARNING_OBJECT (preset, "can not get the keyfile contents: %s",
 747         error->message);
 748     g_error_free (error);
 749     g_free (data);
 750     return FALSE;
 751   }
 752 write_failed:
 753   {
 754     GST_WARNING_OBJECT (preset, "Unable to store preset file %s: %s",
 755         preset_path, error->message);
 756     g_error_free (error);
 757     g_free (data);
 758     return FALSE;
 759   }
 760 }
 761
 762 /* save the preset with the given name */
 763 static gboolean
 764 gst_preset_default_save_preset (GstPreset * preset, const gchar * name)
 765 {
 766   GKeyFile *presets;
 767   gchar **props;
 768   guint i;
 769   GObjectClass *gclass;
 770   gboolean is_child_proxy;
 771
 772   GST_INFO_OBJECT (preset, "saving new preset: %s", name);
 773
 774   /* get the presets from the type */
 775   if (!(presets = preset_get_keyfile (preset)))
 776     goto no_presets;
 777
 778   /* take copies of current gobject properties from preset */
 779   if (!(props = gst_preset_get_property_names (preset)))
 780     goto no_properties;
 781
 782   gclass = G_OBJECT_CLASS (GST_ELEMENT_GET_CLASS (preset));
 783   is_child_proxy = GST_IS_CHILD_PROXY (preset);
 784
 785   /* loop over the object properties and store the property value in the
 786    * keyfile */
 787   for (i = 0; props[i]; i++) {
 788     GValue gvalue = { 0, };
 789     gchar *str;
 790     GParamSpec *property = NULL;
 791
 792     if (is_child_proxy) {
 793       gst_child_proxy_lookup ((GstChildProxy *) preset, props[i], NULL,
 794           &property);
 795     } else {
 796       property = g_object_class_find_property (gclass, props[i]);
 797     }
 798     if (!property) {
 799       /* the element said it supported the property but then it does not have
 800        * that property. This should not happen. */
 801       GST_WARNING_OBJECT (preset, "property '%s' not in object", props[i]);
 802       continue;
 803     }
 804
 805     g_value_init (&gvalue, property->value_type);
 806     if (is_child_proxy) {
 807       gst_child_proxy_get_property ((GstChildProxy *) preset, props[i],
 808           &gvalue);
 809     } else {
 810       g_object_get_property ((GObject *) preset, props[i], &gvalue);
 811     }
 812
 813     if ((str = gst_value_serialize (&gvalue))) {
 814       g_key_file_set_string (presets, name, props[i], (gpointer) str);
 815       g_free (str);
 816     } else {
 817       GST_WARNING_OBJECT (preset, "serialization for property '%s' failed",
 818           props[i]);
 819     }
 820     g_value_unset (&gvalue);
 821   }
 822   GST_INFO_OBJECT (preset, "  saved");
 823   g_strfreev (props);
 824
 825   /* save updated version */
 826   return gst_preset_default_save_presets_file (preset);
 827
 828   /* ERRORS */
 829 no_presets:
 830   {
 831     GST_WARNING_OBJECT (preset, "no presets");
 832     return FALSE;
 833   }
 834 no_properties:
 835   {
 836     GST_INFO_OBJECT (preset, "no properties");
 837     return FALSE;
 838   }
 839 }
 840
 841 /* copies all keys and comments from one group to another, deleting the old
 842  * group. */
 843 static gboolean
 844 gst_preset_default_rename_preset (GstPreset * preset, const gchar * old_name,
 845     const gchar * new_name)
 846 {
 847   GKeyFile *presets;
 848   gchar *str;
 849   gchar **keys;
 850   gsize i, num_keys;
 851
 852   /* get the presets from the type */
 853   if (!(presets = preset_get_keyfile (preset)))
 854     goto no_presets;
 855
 856   if (!g_key_file_has_group (presets, old_name))
 857     goto no_group;
 858
 859   /* copy group comment if there is any */
 860   if ((str = g_key_file_get_comment (presets, old_name, NULL, NULL))) {
 861     g_key_file_set_comment (presets, new_name, NULL, str, NULL);
 862     g_free (str);
 863   }
 864
 865   /* get all keys from the old group and copy them in the new group */
 866   keys = g_key_file_get_keys (presets, old_name, &num_keys, NULL);
 867   for (i = 0; i < num_keys; i++) {
 868     /* copy key comment if there is any */
 869     if ((str = g_key_file_get_comment (presets, old_name, keys[i], NULL))) {
 870       g_key_file_set_comment (presets, new_name, keys[i], str, NULL);
 871       g_free (str);
 872     }
 873     /* copy key value */
 874     str = g_key_file_get_value (presets, old_name, keys[i], NULL);
 875     g_key_file_set_value (presets, new_name, keys[i], str);
 876     g_free (str);
 877   }
 878   g_strfreev (keys);
 879
 880   /* remove old group */
 881   g_key_file_remove_group (presets, old_name, NULL);
 882
 883   /* save updated version */
 884   return gst_preset_default_save_presets_file (preset);
 885
 886   /* ERRORS */
 887 no_presets:
 888   {
 889     GST_WARNING_OBJECT (preset, "no presets");
 890     return FALSE;
 891   }
 892 no_group:
 893   {
 894     GST_WARNING_OBJECT (preset, "no preset named %s", old_name);
 895     return FALSE;
 896   }
 897 }
 898
 899 /* delete a group from the keyfile */
 900 static gboolean
 901 gst_preset_default_delete_preset (GstPreset * preset, const gchar * name)
 902 {
 903   GKeyFile *presets;
 904
 905   /* get the presets from the type */
 906   if (!(presets = preset_get_keyfile (preset)))
 907     goto no_presets;
 908
 909   /* get the group */
 910   if (!g_key_file_has_group (presets, name))
 911     goto no_group;
 912
 913   /* remove the group */
 914   g_key_file_remove_group (presets, name, NULL);
 915
 916   /* save updated version */
 917   return gst_preset_default_save_presets_file (preset);
 918
 919   /* ERRORS */
 920 no_presets:
 921   {
 922     GST_WARNING_OBJECT (preset, "no presets");
 923     return FALSE;
 924   }
 925 no_group:
 926   {
 927     GST_WARNING_OBJECT (preset, "no preset named %s", name);
 928     return FALSE;
 929   }
 930 }
 931
 932 static gboolean
 933 gst_preset_default_set_meta (GstPreset * preset, const gchar * name,
 934     const gchar * tag, const gchar * value)
 935 {
 936   GKeyFile *presets;
 937   gchar *key;
 938
 939   /* get the presets from the type */
 940   if (!(presets = preset_get_keyfile (preset)))
 941     goto no_presets;
 942
 943   key = g_strdup_printf ("_meta/%s", tag);
 944   if (value && *value) {
 945     g_key_file_set_value (presets, name, key, value);
 946   } else {
 947     g_key_file_remove_key (presets, name, key, NULL);
 948   }
 949   g_free (key);
 950
 951   /* save updated keyfile */
 952   return gst_preset_default_save_presets_file (preset);
 953
 954   /* ERRORS */
 955 no_presets:
 956   {
 957     GST_WARNING_OBJECT (preset, "no presets");
 958     return FALSE;
 959   }
 960 }
 961
 962 /* the caller must free @value after usage */
 963 static gboolean
 964 gst_preset_default_get_meta (GstPreset * preset, const gchar * name,
 965     const gchar * tag, gchar ** value)
 966 {
 967   GKeyFile *presets;
 968   gchar *key;
 969
 970   /* get the presets from the type */
 971   if (!(presets = preset_get_keyfile (preset)))
 972     goto no_presets;
 973
 974   key = g_strdup_printf ("_meta/%s", tag);
 975   *value = g_key_file_get_value (presets, name, key, NULL);
 976   g_free (key);
 977
 978   return TRUE;
 979
 980   /* ERRORS */
 981 no_presets:
 982   {
 983     GST_WARNING_OBJECT (preset, "no presets");
 984     *value = NULL;
 985     return FALSE;
 986   }
 987 }
 988
 989 /* wrapper */
 990
 991 /**
 992  * gst_preset_get_preset_names:
 993  * @preset: a #GObject that implements #GstPreset
 994  *
 995  * Get a copy of preset names as a %NULL terminated string array.
 996  *
 997  * Returns: (transfer full) (array zero-terminated=1) (element-type gchar*):
 998  *     list with names, use g_strfreev() after usage.
 999  */
1000 gchar **
1001 gst_preset_get_preset_names (GstPreset * preset)
1002 {
1003   g_return_val_if_fail (GST_IS_PRESET (preset), NULL);
1004
1005   return (GST_PRESET_GET_INTERFACE (preset)->get_preset_names (preset));
1006 }
1007
1008 /**
1009  * gst_preset_get_property_names:
1010  * @preset: a #GObject that implements #GstPreset
1011  *
1012  * Get a the names of the GObject properties that can be used for presets.
1013  *
1014  * Returns: (transfer full) (array zero-terminated=1) (element-type gchar*): an
1015  *   array of property names which should be freed with g_strfreev() after use.
1016  */
1017 gchar **
1018 gst_preset_get_property_names (GstPreset * preset)
1019 {
1020   g_return_val_if_fail (GST_IS_PRESET (preset), NULL);
1021
1022   return (GST_PRESET_GET_INTERFACE (preset)->get_property_names (preset));
1023 }
1024
1025 /**
1026  * gst_preset_load_preset:
1027  * @preset: a #GObject that implements #GstPreset
1028  * @name: preset name to load
1029  *
1030  * Load the given preset.
1031  *
1032  * Returns: %TRUE for success, %FALSE if e.g. there is no preset with that @name
1033  */
1034 gboolean
1035 gst_preset_load_preset (GstPreset * preset, const gchar * name)
1036 {
1037   g_return_val_if_fail (GST_IS_PRESET (preset), FALSE);
1038   g_return_val_if_fail (name, FALSE);
1039
1040   return (GST_PRESET_GET_INTERFACE (preset)->load_preset (preset, name));
1041 }
1042
1043 /**
1044  * gst_preset_save_preset:
1045  * @preset: a #GObject that implements #GstPreset
1046  * @name: preset name to save
1047  *
1048  * Save the current object settings as a preset under the given name. If there
1049  * is already a preset by this @name it will be overwritten.
1050  *
1051  * Returns: %TRUE for success, %FALSE
1052  */
1053 gboolean
1054 gst_preset_save_preset (GstPreset * preset, const gchar * name)
1055 {
1056   g_return_val_if_fail (GST_IS_PRESET (preset), FALSE);
1057   g_return_val_if_fail (name, FALSE);
1058
1059   return (GST_PRESET_GET_INTERFACE (preset)->save_preset (preset, name));
1060 }
1061
1062 /**
1063  * gst_preset_rename_preset:
1064  * @preset: a #GObject that implements #GstPreset
1065  * @old_name: current preset name
1066  * @new_name: new preset name
1067  *
1068  * Renames a preset. If there is already a preset by the @new_name it will be
1069  * overwritten.
1070  *
1071  * Returns: %TRUE for success, %FALSE if e.g. there is no preset with @old_name
1072  */
1073 gboolean
1074 gst_preset_rename_preset (GstPreset * preset, const gchar * old_name,
1075     const gchar * new_name)
1076 {
1077   g_return_val_if_fail (GST_IS_PRESET (preset), FALSE);
1078   g_return_val_if_fail (old_name, FALSE);
1079   g_return_val_if_fail (new_name, FALSE);
1080
1081   return (GST_PRESET_GET_INTERFACE (preset)->rename_preset (preset, old_name,
1082           new_name));
1083 }
1084
1085 /**
1086  * gst_preset_delete_preset:
1087  * @preset: a #GObject that implements #GstPreset
1088  * @name: preset name to remove
1089  *
1090  * Delete the given preset.
1091  *
1092  * Returns: %TRUE for success, %FALSE if e.g. there is no preset with that @name
1093  */
1094 gboolean
1095 gst_preset_delete_preset (GstPreset * preset, const gchar * name)
1096 {
1097   g_return_val_if_fail (GST_IS_PRESET (preset), FALSE);
1098   g_return_val_if_fail (name, FALSE);
1099
1100   return (GST_PRESET_GET_INTERFACE (preset)->delete_preset (preset, name));
1101 }
1102
1103 /**
1104  * gst_preset_set_meta:
1105  * @preset: a #GObject that implements #GstPreset
1106  * @name: preset name
1107  * @tag: meta data item name
1108  * @value: (allow-none): new value
1109  *
1110  * Sets a new @value for an existing meta data item or adds a new item. Meta
1111  * data @tag names can be something like e.g. "comment". Supplying %NULL for the
1112  * @value will unset an existing value.
1113  *
1114  * Returns: %TRUE for success, %FALSE if e.g. there is no preset with that @name
1115  */
1116 gboolean
1117 gst_preset_set_meta (GstPreset * preset, const gchar * name, const gchar * tag,
1118     const gchar * value)
1119 {
1120   g_return_val_if_fail (GST_IS_PRESET (preset), FALSE);
1121   g_return_val_if_fail (name, FALSE);
1122   g_return_val_if_fail (tag, FALSE);
1123
1124   return GST_PRESET_GET_INTERFACE (preset)->set_meta (preset, name, tag, value);
1125 }
1126
1127 /**
1128  * gst_preset_get_meta:
1129  * @preset: a #GObject that implements #GstPreset
1130  * @name: preset name
1131  * @tag: meta data item name
1132  * @value: (out callee-allocates): value
1133  *
1134  * Gets the @value for an existing meta data @tag. Meta data @tag names can be
1135  * something like e.g. "comment". Returned values need to be released when done.
1136  *
1137  * Returns: %TRUE for success, %FALSE if e.g. there is no preset with that @name
1138  * or no value for the given @tag
1139  */
1140 gboolean
1141 gst_preset_get_meta (GstPreset * preset, const gchar * name, const gchar * tag,
1142     gchar ** value)
1143 {
1144   g_return_val_if_fail (GST_IS_PRESET (preset), FALSE);
1145   g_return_val_if_fail (name, FALSE);
1146   g_return_val_if_fail (tag, FALSE);
1147   g_return_val_if_fail (value, FALSE);
1148
1149   return GST_PRESET_GET_INTERFACE (preset)->get_meta (preset, name, tag, value);
1150 }
1151
1152 /**
1153  * gst_preset_set_app_dir:
1154  * @app_dir: the application specific preset dir
1155  *
1156  * Sets an extra directory as an absolute path that should be considered when
1157  * looking for presets. Any presets in the application dir will shadow the
1158  * system presets.
1159  *
1160  * Returns: %TRUE for success, %FALSE if the dir already has been set
1161  */
1162 gboolean
1163 gst_preset_set_app_dir (const gchar * app_dir)
1164 {
1165   g_return_val_if_fail (app_dir, FALSE);
1166
1167   if (!preset_app_dir) {
1168     preset_app_dir = g_strdup (app_dir);
1169     return TRUE;
1170   }
1171   return FALSE;
1172 }
1173
1174 /**
1175  * gst_preset_get_app_dir:
1176  *
1177  * Gets the directory for application specific presets if set by the
1178  * application.
1179  *
1180  * Returns: (nullable): the directory or %NULL, don't free or modify
1181  * the string
1182  */
1183 const gchar *
1184 gst_preset_get_app_dir (void)
1185 {
1186   return preset_app_dir;
1187 }
1188
1189 /**
1190  * gst_preset_is_editable:
1191  * @preset: a #GObject that implements #GstPreset
1192  *
1193  * Check if one can add new presets, change existing ones and remove presets.
1194  *
1195  * Returns: %TRUE if presets are editable or %FALSE if they are static
1196  *
1197  * Since: 1.6
1198  */
1199 gboolean
1200 gst_preset_is_editable (GstPreset * preset)
1201 {
1202   GstPresetInterface *iface = GST_PRESET_GET_INTERFACE (preset);
1203
1204   return iface->save_preset && iface->delete_preset;
1205 }
1206
1207 /* class internals */
1208
1209 static void
1210 gst_preset_class_init (GstPresetInterface * iface)
1211 {
1212   iface->get_preset_names = gst_preset_default_get_preset_names;
1213   iface->get_property_names = gst_preset_default_get_property_names;
1214
1215   iface->load_preset = gst_preset_default_load_preset;
1216   iface->save_preset = gst_preset_default_save_preset;
1217   iface->rename_preset = gst_preset_default_rename_preset;
1218   iface->delete_preset = gst_preset_default_delete_preset;
1219
1220   iface->set_meta = gst_preset_default_set_meta;
1221   iface->get_meta = gst_preset_default_get_meta;
1222 }
1223
1224 static void
1225 gst_preset_base_init (gpointer g_class)
1226 {
1227   static gboolean initialized = FALSE;
1228
1229   if (!initialized) {
1230     /* init default implementation */
1231     GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "preset",
1232         GST_DEBUG_FG_WHITE | GST_DEBUG_BG_BLACK, "preset interface");
1233
1234     /* create quarks for use with g_type_{g,s}et_qdata() */
1235     preset_quark = g_quark_from_static_string ("GstPreset::presets");
1236     preset_user_path_quark =
1237         g_quark_from_static_string ("GstPreset::user_path");
1238     preset_app_path_quark = g_quark_from_static_string ("GstPreset::app_path");
1239     preset_system_path_quark =
1240         g_quark_from_static_string ("GstPreset::system_path");
1241
1242 #if 0
1243     /* create interface properties, each element would need to override this
1244      *   g_object_class_override_property(gobject_class, PROP_PRESET_NAME, "preset-name");
1245      * and in _set_property() do
1246      *   case PROP_PRESET_NAME: {
1247      *     gchar *name = g_value_get_string (value);
1248      *     if (name)
1249      *       gst_preset_load_preset(preset, name);
1250      *   } break;
1251      */
1252     g_object_interface_install_property (g_class,
1253         g_param_spec_string ("preset-name",
1254             "preset-name property",
1255             "load given preset", NULL, G_PARAM_WRITABLE));
1256 #endif
1257
1258     initialized = TRUE;
1259   }
1260 }
1261
1262 GType
1263 gst_preset_get_type (void)
1264 {
1265   static volatile gsize type = 0;
1266
1267   if (g_once_init_enter (&type)) {
1268     GType _type;
1269     const GTypeInfo info = {
1270       sizeof (GstPresetInterface),
1271       (GBaseInitFunc) gst_preset_base_init,     /* base_init */
1272       NULL,                     /* base_finalize */
1273       (GClassInitFunc) gst_preset_class_init,   /* class_init */
1274       NULL,                     /* class_finalize */
1275       NULL,                     /* class_data */
1276       0,
1277       0,                        /* n_preallocs */
1278       NULL                      /* instance_init */
1279     };
1280     _type = g_type_register_static (G_TYPE_INTERFACE, "GstPreset", &info, 0);
1281     g_once_init_leave (&type, _type);
1282   }
1283   return type;
1284 }