2 * Copyright (C) 2006 Josep Torra <josep@fluendo.com>
3 * 2006 Mathieu Garcia <matthieu@fluendo.com>
4 * 2006,2007 Stefan Kost <ensonic@users.sf.net>
5 * 2008 Sebastian Dröge <slomo@circular-chaos.org>
6 * 2008 Jan Schmidt <jan.schmidt@sun.com>
8 * gstregistrychunks.c: GstRegistryChunk helper for serialising/deserialising
9 * plugin entries and features.
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Library General Public License for more details.
21 * You should have received a copy of the GNU Library General Public
22 * License along with this library; if not, write to the
23 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 * Boston, MA 02111-1307, USA.
31 #include <gst/gst_private.h>
32 #include <gst/gstconfig.h>
33 #include <gst/gstelement.h>
34 #include <gst/gsttypefind.h>
35 #include <gst/gsttypefindfactory.h>
36 #include <gst/gsturi.h>
37 #include <gst/gstinfo.h>
38 #include <gst/gstenumtypes.h>
39 #include <gst/gstpadtemplate.h>
41 #include <gst/gstregistrychunks.h>
43 #define GST_CAT_DEFAULT GST_CAT_REGISTRY
45 /* count string length, but return -1 if we hit the eof */
47 _strnlen (const gchar * str, gint maxlen)
51 while (G_LIKELY (len < maxlen)) {
52 if (G_UNLIKELY (str[len] == '\0'))
60 #define unpack_element(inptr, outptr, element, endptr, error_label) G_STMT_START{ \
61 if (inptr + sizeof(element) > endptr) { \
62 GST_ERROR ("Failed reading element " G_STRINGIFY (element) \
63 ". Have %d bytes need %" G_GSSIZE_FORMAT, \
64 (int) (endptr - inptr), sizeof(element)); \
67 outptr = (element *) inptr; \
68 inptr += sizeof (element); \
71 #define unpack_const_string(inptr, outptr, endptr, error_label) G_STMT_START{\
72 gint _len = _strnlen (inptr, (endptr-inptr)); \
75 outptr = g_intern_string ((const gchar *)inptr); \
79 #define unpack_string(inptr, outptr, endptr, error_label) G_STMT_START{\
80 gint _len = _strnlen (inptr, (endptr-inptr)); \
83 outptr = g_memdup ((gconstpointer)inptr, _len + 1); \
87 #define unpack_string_nocopy(inptr, outptr, endptr, error_label) G_STMT_START{\
88 gint _len = _strnlen (inptr, (endptr-inptr)); \
91 outptr = (const gchar *)inptr; \
95 #define ALIGNMENT (sizeof (void *))
96 #define alignment(_address) (gsize)_address%ALIGNMENT
97 #define align(_ptr) _ptr += (( alignment(_ptr) == 0) ? 0 : ALIGNMENT-alignment(_ptr))
100 _priv_gst_registry_chunk_free (GstRegistryChunk * chunk)
102 if (!(chunk->flags & GST_REGISTRY_CHUNK_FLAG_CONST)) {
103 if ((chunk->flags & GST_REGISTRY_CHUNK_FLAG_MALLOC))
104 g_free (chunk->data);
106 g_slice_free1 (chunk->size, chunk->data);
108 g_slice_free (GstRegistryChunk, chunk);
112 * gst_registry_chunks_save_const_string:
114 * Store a const string in a binary chunk.
116 * Returns: %TRUE for success
118 inline static gboolean
119 gst_registry_chunks_save_const_string (GList ** list, const gchar * str)
121 GstRegistryChunk *chunk;
123 if (G_UNLIKELY (str == NULL)) {
124 GST_ERROR ("unexpected NULL string in plugin or plugin feature data");
128 chunk = g_slice_new (GstRegistryChunk);
129 chunk->data = (gpointer) str;
130 chunk->size = strlen ((gchar *) chunk->data) + 1;
131 chunk->flags = GST_REGISTRY_CHUNK_FLAG_CONST;
132 chunk->align = FALSE;
133 *list = g_list_prepend (*list, chunk);
138 * gst_registry_chunks_save_string:
140 * Store a string in a binary chunk.
142 * Returns: %TRUE for success
144 inline static gboolean
145 gst_registry_chunks_save_string (GList ** list, gchar * str)
147 GstRegistryChunk *chunk;
149 chunk = g_slice_new (GstRegistryChunk);
151 chunk->size = strlen ((gchar *) chunk->data) + 1;
152 chunk->flags = GST_REGISTRY_CHUNK_FLAG_MALLOC;
153 chunk->align = FALSE;
154 *list = g_list_prepend (*list, chunk);
159 * gst_registry_chunks_save_data:
161 * Store some data in a binary chunk.
163 * Returns: the initialized chunk
165 inline static GstRegistryChunk *
166 gst_registry_chunks_make_data (gpointer data, gulong size)
168 GstRegistryChunk *chunk;
170 chunk = g_slice_new (GstRegistryChunk);
173 chunk->flags = GST_REGISTRY_CHUNK_FLAG_NONE;
180 * gst_registry_chunks_save_pad_template:
182 * Store pad_templates in binary chunks.
184 * Returns: %TRUE for success
187 gst_registry_chunks_save_pad_template (GList ** list,
188 GstStaticPadTemplate * template)
190 GstRegistryChunkPadTemplate *pt;
191 GstRegistryChunk *chk;
193 pt = g_slice_new (GstRegistryChunkPadTemplate);
195 gst_registry_chunks_make_data (pt, sizeof (GstRegistryChunkPadTemplate));
197 pt->presence = template->presence;
198 pt->direction = template->direction;
200 /* pack pad template strings */
201 gst_registry_chunks_save_const_string (list,
202 (gchar *) (template->static_caps.string));
203 gst_registry_chunks_save_const_string (list, template->name_template);
205 *list = g_list_prepend (*list, chk);
211 * gst_registry_chunks_save_feature:
213 * Store features in binary chunks.
215 * Returns: %TRUE for success
218 gst_registry_chunks_save_feature (GList ** list, GstPluginFeature * feature)
220 const gchar *type_name = g_type_name (G_OBJECT_TYPE (feature));
221 GstRegistryChunkPluginFeature *pf = NULL;
222 GstRegistryChunk *chk = NULL;
226 GST_ERROR ("NULL feature type_name, aborting.");
230 if (GST_IS_ELEMENT_FACTORY (feature)) {
231 GstRegistryChunkElementFactory *ef;
232 GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
234 /* Initialize with zeroes because of struct padding and
235 * valgrind complaining about copying unitialized memory
237 ef = g_slice_new0 (GstRegistryChunkElementFactory);
239 gst_registry_chunks_make_data (ef,
240 sizeof (GstRegistryChunkElementFactory));
241 ef->npadtemplates = ef->ninterfaces = ef->nuriprotocols = 0;
242 pf = (GstRegistryChunkPluginFeature *) ef;
244 /* save interfaces */
245 for (walk = factory->interfaces; walk;
246 walk = g_list_next (walk), ef->ninterfaces++) {
247 gst_registry_chunks_save_const_string (list, (gchar *) walk->data);
249 GST_DEBUG ("Feature %s: saved %d interfaces %d pad templates",
250 GST_OBJECT_NAME (feature), ef->ninterfaces, ef->npadtemplates);
253 if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {
254 if (factory->uri_protocols && *factory->uri_protocols) {
255 GstRegistryChunk *subchk;
259 gst_registry_chunks_make_data (&factory->uri_type,
260 sizeof (factory->uri_type));
261 subchk->flags = GST_REGISTRY_CHUNK_FLAG_CONST;
263 protocol = factory->uri_protocols;
265 gst_registry_chunks_save_const_string (list, *protocol++);
268 *list = g_list_prepend (*list, subchk);
269 GST_DEBUG ("Saved %d UriTypes", ef->nuriprotocols);
271 g_warning ("GStreamer feature '%s' is URI handler but does not provide"
272 " any protocols it can handle", GST_OBJECT_NAME (feature));
276 /* save pad-templates */
277 for (walk = factory->staticpadtemplates; walk;
278 walk = g_list_next (walk), ef->npadtemplates++) {
279 GstStaticPadTemplate *template = walk->data;
281 if (!gst_registry_chunks_save_pad_template (list, template)) {
282 GST_ERROR ("Can't fill pad template, aborting.");
287 /* pack element metadata strings */
288 gst_registry_chunks_save_string (list,
289 gst_structure_to_string (factory->metadata));
290 } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
291 GstRegistryChunkTypeFindFactory *tff;
292 GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
295 /* Initialize with zeroes because of struct padding and
296 * valgrind complaining about copying unitialized memory
298 tff = g_slice_new0 (GstRegistryChunkTypeFindFactory);
300 gst_registry_chunks_make_data (tff,
301 sizeof (GstRegistryChunkTypeFindFactory));
302 tff->nextensions = 0;
303 pf = (GstRegistryChunkPluginFeature *) tff;
305 /* save extensions */
306 if (factory->extensions) {
307 while (factory->extensions[tff->nextensions]) {
308 gst_registry_chunks_save_const_string (list,
309 factory->extensions[tff->nextensions++]);
314 /* we copy the caps here so we can simplify them before saving. This
315 * is a lot faster when loading them later on */
316 GstCaps *copy = gst_caps_copy (factory->caps);
318 gst_caps_do_simplify (copy);
319 str = gst_caps_to_string (copy);
320 gst_caps_unref (copy);
321 gst_registry_chunks_save_string (list, str);
323 gst_registry_chunks_save_const_string (list, "");
325 } else if (GST_IS_INDEX_FACTORY (feature)) {
326 GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
328 pf = g_slice_new (GstRegistryChunkPluginFeature);
330 gst_registry_chunks_make_data (pf,
331 sizeof (GstRegistryChunkPluginFeature));
333 /* pack element factory strings */
334 gst_registry_chunks_save_const_string (list, factory->longdesc);
336 GST_WARNING ("unhandled feature type '%s'", type_name);
340 pf->rank = feature->rank;
341 *list = g_list_prepend (*list, chk);
343 /* pack plugin feature strings */
344 gst_registry_chunks_save_const_string (list, GST_OBJECT_NAME (feature));
345 gst_registry_chunks_save_const_string (list, (gchar *) type_name);
358 gst_registry_chunks_save_plugin_dep (GList ** list, GstPluginDep * dep)
360 GstRegistryChunkDep *ed;
361 GstRegistryChunk *chk;
364 ed = g_slice_new (GstRegistryChunkDep);
365 chk = gst_registry_chunks_make_data (ed, sizeof (GstRegistryChunkDep));
367 ed->flags = dep->flags;
372 ed->env_hash = dep->env_hash;
373 ed->stat_hash = dep->stat_hash;
375 for (s = dep->env_vars; s != NULL && *s != NULL; ++s, ++ed->n_env_vars)
376 gst_registry_chunks_save_string (list, g_strdup (*s));
378 for (s = dep->paths; s != NULL && *s != NULL; ++s, ++ed->n_paths)
379 gst_registry_chunks_save_string (list, g_strdup (*s));
381 for (s = dep->names; s != NULL && *s != NULL; ++s, ++ed->n_names)
382 gst_registry_chunks_save_string (list, g_strdup (*s));
384 *list = g_list_prepend (*list, chk);
386 GST_LOG ("Saved external plugin dependency");
391 * _priv_gst_registry_chunks_save_plugin:
393 * Adapt a GstPlugin to our GstRegistryChunkPluginElement structure, and
394 * prepend it as a GstRegistryChunk in the provided list.
398 _priv_gst_registry_chunks_save_plugin (GList ** list, GstRegistry * registry,
401 GstRegistryChunkPluginElement *pe;
402 GstRegistryChunk *chk;
403 GList *plugin_features = NULL;
406 pe = g_slice_new (GstRegistryChunkPluginElement);
408 gst_registry_chunks_make_data (pe,
409 sizeof (GstRegistryChunkPluginElement));
411 pe->file_size = plugin->file_size;
412 pe->file_mtime = plugin->file_mtime;
416 /* pack external deps */
417 for (walk = plugin->priv->deps; walk != NULL; walk = walk->next) {
418 if (!gst_registry_chunks_save_plugin_dep (list, walk->data)) {
419 GST_ERROR ("Could not save external plugin dependency, aborting.");
425 /* pack plugin features */
427 gst_registry_get_feature_list_by_plugin (registry, plugin->desc.name);
428 for (walk = plugin_features; walk; walk = g_list_next (walk), pe->nfeatures++) {
429 GstPluginFeature *feature = GST_PLUGIN_FEATURE (walk->data);
431 if (!gst_registry_chunks_save_feature (list, feature)) {
432 GST_ERROR ("Can't fill plugin feature, aborting.");
437 gst_plugin_feature_list_free (plugin_features);
439 /* pack cache data */
440 if (plugin->priv->cache_data) {
441 gchar *cache_str = gst_structure_to_string (plugin->priv->cache_data);
442 gst_registry_chunks_save_string (list, cache_str);
444 gst_registry_chunks_save_const_string (list, "");
447 /* pack plugin element strings */
448 gst_registry_chunks_save_const_string (list,
449 (plugin->desc.release_datetime) ? plugin->desc.release_datetime : "");
450 gst_registry_chunks_save_const_string (list, plugin->desc.origin);
451 gst_registry_chunks_save_const_string (list, plugin->desc.package);
452 gst_registry_chunks_save_const_string (list, plugin->desc.source);
453 gst_registry_chunks_save_const_string (list, plugin->desc.license);
454 gst_registry_chunks_save_const_string (list, plugin->desc.version);
455 gst_registry_chunks_save_const_string (list, plugin->filename);
456 gst_registry_chunks_save_const_string (list, plugin->desc.description);
457 gst_registry_chunks_save_const_string (list, plugin->desc.name);
459 *list = g_list_prepend (*list, chk);
461 GST_DEBUG ("Found %d features in plugin \"%s\"", pe->nfeatures,
467 gst_plugin_feature_list_free (plugin_features);
474 * gst_registry_chunks_load_pad_template:
476 * Make a new GstStaticPadTemplate from current GstRegistryChunkPadTemplate
479 * Returns: new GstStaticPadTemplate
482 gst_registry_chunks_load_pad_template (GstElementFactory * factory, gchar ** in,
485 GstRegistryChunkPadTemplate *pt;
486 GstStaticPadTemplate *template = NULL;
489 GST_DEBUG ("Reading/casting for GstRegistryChunkPadTemplate at address %p",
491 unpack_element (*in, pt, GstRegistryChunkPadTemplate, end, fail);
493 template = g_slice_new (GstStaticPadTemplate);
494 template->presence = pt->presence;
495 template->direction = pt->direction;
496 template->static_caps.caps.mini_object.refcount = 0;
498 /* unpack pad template strings */
499 unpack_const_string (*in, template->name_template, end, fail);
500 unpack_const_string (*in, template->static_caps.string, end, fail);
502 __gst_element_factory_add_static_pad_template (factory, template);
503 GST_DEBUG ("Added pad_template %s", template->name_template);
507 GST_INFO ("Reading pad template failed");
509 g_slice_free (GstStaticPadTemplate, template);
514 * gst_registry_chunks_load_feature:
516 * Make a new GstPluginFeature from current binary plugin feature structure
518 * Returns: new GstPluginFeature
521 gst_registry_chunks_load_feature (GstRegistry * registry, gchar ** in,
522 gchar * end, GstPlugin * plugin)
524 GstRegistryChunkPluginFeature *pf = NULL;
525 GstPluginFeature *feature = NULL;
526 const gchar *const_str, *type_name;
527 const gchar *feature_name;
528 const gchar *plugin_name;
533 plugin_name = plugin->desc.name;
535 /* unpack plugin feature strings */
536 unpack_string_nocopy (*in, type_name, end, fail);
538 if (G_UNLIKELY (!type_name)) {
539 GST_ERROR ("No feature type name");
543 /* unpack more plugin feature strings */
544 unpack_string_nocopy (*in, feature_name, end, fail);
546 GST_DEBUG ("Plugin '%s' feature '%s' typename : '%s'", plugin_name,
547 feature_name, type_name);
549 if (G_UNLIKELY (!(type = g_type_from_name (type_name)))) {
550 GST_ERROR ("Unknown type from typename '%s' for plugin '%s'", type_name,
554 if (G_UNLIKELY ((feature = g_object_newv (type, 0, NULL)) == NULL)) {
555 GST_ERROR ("Can't create feature from type");
558 gst_plugin_feature_set_name (feature, feature_name);
560 if (G_UNLIKELY (!GST_IS_PLUGIN_FEATURE (feature))) {
561 GST_ERROR ("typename : '%s' is not a plugin feature", type_name);
565 if (GST_IS_ELEMENT_FACTORY (feature)) {
566 GstRegistryChunkElementFactory *ef;
568 GstElementFactory *factory = GST_ELEMENT_FACTORY_CAST (feature);
570 const gchar *meta_data_str;
573 GST_LOG ("Reading/casting for GstRegistryChunkElementFactory at address %p",
575 unpack_element (*in, ef, GstRegistryChunkElementFactory, end, fail);
576 pf = (GstRegistryChunkPluginFeature *) ef;
578 /* unpack element factory strings */
579 unpack_string_nocopy (*in, meta_data_str, end, fail);
580 if (meta_data_str && *meta_data_str) {
581 factory->metadata = gst_structure_from_string (meta_data_str, NULL);
582 if (!factory->metadata) {
584 ("Error when trying to deserialize structure for metadata '%s'",
589 n = ef->npadtemplates;
590 GST_DEBUG ("Element factory : npadtemplates=%d", n);
592 /* load pad templates */
593 for (i = 0; i < n; i++) {
594 if (G_UNLIKELY (!gst_registry_chunks_load_pad_template (factory, in,
596 GST_ERROR ("Error while loading binary pad template");
602 if (G_UNLIKELY ((n = ef->nuriprotocols))) {
603 GST_DEBUG ("Reading %d UriTypes at address %p", n, *in);
606 factory->uri_type = *((guint *) * in);
607 *in += sizeof (factory->uri_type);
608 /*unpack_element(*in, &factory->uri_type, factory->uri_type, end, fail); */
610 factory->uri_protocols = g_new0 (gchar *, n + 1);
611 for (i = 0; i < n; i++) {
612 unpack_string (*in, str, end, fail);
613 factory->uri_protocols[i] = str;
616 /* load interfaces */
617 if (G_UNLIKELY ((n = ef->ninterfaces))) {
618 GST_DEBUG ("Reading %d Interfaces at address %p", n, *in);
619 for (i = 0; i < n; i++) {
620 unpack_string_nocopy (*in, const_str, end, fail);
621 __gst_element_factory_add_interface (factory, const_str);
624 } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
625 GstRegistryChunkTypeFindFactory *tff;
626 GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
630 ("Reading/casting for GstRegistryChunkPluginFeature at address %p",
632 unpack_element (*in, tff, GstRegistryChunkTypeFindFactory, end, fail);
633 pf = (GstRegistryChunkPluginFeature *) tff;
635 /* load typefinder caps */
636 unpack_string_nocopy (*in, const_str, end, fail);
637 if (const_str != NULL && *const_str != '\0')
638 factory->caps = gst_caps_from_string (const_str);
640 factory->caps = NULL;
642 /* load extensions */
643 if (tff->nextensions) {
644 GST_DEBUG ("Reading %d Typefind extensions at address %p",
645 tff->nextensions, *in);
646 factory->extensions = g_new0 (gchar *, tff->nextensions + 1);
647 /* unpack in reverse order to maintain the correct order */
648 for (i = tff->nextensions; i > 0; i--) {
649 unpack_string (*in, str, end, fail);
650 factory->extensions[i - 1] = str;
653 } else if (GST_IS_INDEX_FACTORY (feature)) {
654 GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
658 ("Reading/casting for GstRegistryChunkPluginFeature at address %p",
660 unpack_element (*in, pf, GstRegistryChunkPluginFeature, end, fail);
662 /* unpack index factory strings */
663 unpack_string (*in, factory->longdesc, end, fail);
665 GST_WARNING ("unhandled factory type : %s", G_OBJECT_TYPE_NAME (feature));
669 feature->rank = pf->rank;
671 feature->plugin_name = plugin_name;
672 feature->plugin = plugin;
673 g_object_add_weak_pointer ((GObject *) plugin,
674 (gpointer *) & feature->plugin);
676 gst_registry_add_feature (registry, feature);
677 GST_DEBUG ("Added feature %s, plugin %p %s", GST_OBJECT_NAME (feature),
678 plugin, plugin_name);
684 GST_INFO ("Reading plugin feature failed");
686 if (GST_IS_OBJECT (feature))
687 gst_object_unref (feature);
689 g_object_unref (feature);
695 gst_registry_chunks_load_plugin_dep_strv (gchar ** in, gchar * end, guint n)
702 arr = g_new0 (gchar *, n + 1);
704 unpack_string (*in, arr[n - 1], end, fail);
709 GST_INFO ("Reading plugin dependency strings failed");
714 gst_registry_chunks_load_plugin_dep (GstPlugin * plugin, gchar ** in,
718 GstRegistryChunkDep *d;
722 GST_LOG_OBJECT (plugin, "Unpacking GstRegistryChunkDep from %p", *in);
723 unpack_element (*in, d, GstRegistryChunkDep, end, fail);
725 dep = g_slice_new (GstPluginDep);
727 dep->env_hash = d->env_hash;
728 dep->stat_hash = d->stat_hash;
730 dep->flags = d->flags;
732 dep->names = gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_names);
733 dep->paths = gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_paths);
735 gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_env_vars);
737 plugin->priv->deps = g_list_append (plugin->priv->deps, dep);
739 GST_DEBUG_OBJECT (plugin, "Loaded external plugin dependency from registry: "
740 "env_hash: %08x, stat_hash: %08x", dep->env_hash, dep->stat_hash);
741 for (s = dep->env_vars; s != NULL && *s != NULL; ++s)
742 GST_LOG_OBJECT (plugin, " evar: %s", *s);
743 for (s = dep->paths; s != NULL && *s != NULL; ++s)
744 GST_LOG_OBJECT (plugin, " path: %s", *s);
745 for (s = dep->names; s != NULL && *s != NULL; ++s)
746 GST_LOG_OBJECT (plugin, " name: %s", *s);
750 GST_INFO ("Reading plugin dependency failed");
756 * _priv_gst_registry_chunks_load_plugin:
758 * Make a new GstPlugin from current GstRegistryChunkPluginElement structure
759 * and add it to the GstRegistry. Return an offset to the next
760 * GstRegistryChunkPluginElement structure.
763 _priv_gst_registry_chunks_load_plugin (GstRegistry * registry, gchar ** in,
764 gchar * end, GstPlugin ** out_plugin)
766 #ifndef GST_DISABLE_GST_DEBUG
769 GstRegistryChunkPluginElement *pe;
770 const gchar *cache_str = NULL;
771 GstPlugin *plugin = NULL;
775 GST_LOG ("Reading/casting for GstRegistryChunkPluginElement at address %p",
777 unpack_element (*in, pe, GstRegistryChunkPluginElement, end, fail);
779 plugin = g_object_newv (GST_TYPE_PLUGIN, 0, NULL);
781 /* TODO: also set GST_PLUGIN_FLAG_CONST */
782 plugin->flags |= GST_PLUGIN_FLAG_CACHED;
783 plugin->file_mtime = pe->file_mtime;
784 plugin->file_size = pe->file_size;
786 /* unpack plugin element strings */
787 unpack_const_string (*in, plugin->desc.name, end, fail);
788 unpack_const_string (*in, plugin->desc.description, end, fail);
789 unpack_string (*in, plugin->filename, end, fail);
790 unpack_const_string (*in, plugin->desc.version, end, fail);
791 unpack_const_string (*in, plugin->desc.license, end, fail);
792 unpack_const_string (*in, plugin->desc.source, end, fail);
793 unpack_const_string (*in, plugin->desc.package, end, fail);
794 unpack_const_string (*in, plugin->desc.origin, end, fail);
795 unpack_const_string (*in, plugin->desc.release_datetime, end, fail);
797 GST_LOG ("read strings for name='%s'", plugin->desc.name);
798 GST_LOG (" desc.description='%s'", plugin->desc.description);
799 GST_LOG (" filename='%s'", plugin->filename);
800 GST_LOG (" desc.version='%s'", plugin->desc.version);
801 GST_LOG (" desc.license='%s'", plugin->desc.license);
802 GST_LOG (" desc.source='%s'", plugin->desc.source);
803 GST_LOG (" desc.package='%s'", plugin->desc.package);
804 GST_LOG (" desc.origin='%s'", plugin->desc.origin);
805 GST_LOG (" desc.datetime=%s", plugin->desc.release_datetime);
807 if (plugin->desc.release_datetime[0] == '\0')
808 plugin->desc.release_datetime = NULL;
810 /* unpack cache data */
811 unpack_string_nocopy (*in, cache_str, end, fail);
812 if (cache_str != NULL && *cache_str != '\0')
813 plugin->priv->cache_data = gst_structure_from_string (cache_str, NULL);
815 /* If the license string is 'BLACKLIST', mark this as a blacklisted
817 if (strcmp (plugin->desc.license, "BLACKLIST") == 0)
818 plugin->flags |= GST_PLUGIN_FLAG_BLACKLISTED;
820 plugin->basename = g_path_get_basename (plugin->filename);
822 /* Takes ownership of plugin */
823 gst_registry_add_plugin (registry, plugin);
825 GST_DEBUG ("Added plugin '%s' plugin with %d features from binary registry",
826 plugin->desc.name, n);
828 /* Load plugin features */
829 for (i = 0; i < n; i++) {
830 if (G_UNLIKELY (!gst_registry_chunks_load_feature (registry, in, end,
832 GST_ERROR ("Error while loading binary feature for plugin '%s'",
833 GST_STR_NULL (plugin->desc.name));
834 gst_registry_remove_plugin (registry, plugin);
839 /* Load external plugin dependencies */
840 for (i = 0; i < pe->n_deps; ++i) {
841 if (G_UNLIKELY (!gst_registry_chunks_load_plugin_dep (plugin, in, end))) {
842 GST_ERROR_OBJECT (plugin, "Could not read external plugin dependency "
843 "for plugin '%s'", GST_STR_NULL (plugin->desc.name));
844 gst_registry_remove_plugin (registry, plugin);
850 *out_plugin = plugin;
856 GST_INFO ("Reading plugin failed after %u bytes", (guint) (end - start));
861 _priv_gst_registry_chunks_save_global_header (GList ** list,
862 GstRegistry * registry, guint32 filter_env_hash)
864 GstRegistryChunkGlobalHeader *hdr;
865 GstRegistryChunk *chk;
867 hdr = g_slice_new (GstRegistryChunkGlobalHeader);
868 chk = gst_registry_chunks_make_data (hdr,
869 sizeof (GstRegistryChunkGlobalHeader));
871 hdr->filter_env_hash = filter_env_hash;
873 *list = g_list_prepend (*list, chk);
875 GST_LOG ("Saved global header (filter_env_hash=0x%08x)", filter_env_hash);
879 _priv_gst_registry_chunks_load_global_header (GstRegistry * registry,
880 gchar ** in, gchar * end, guint32 * filter_env_hash)
882 GstRegistryChunkGlobalHeader *hdr;
885 GST_LOG ("Reading/casting for GstRegistryChunkGlobalHeader at %p", *in);
886 unpack_element (*in, hdr, GstRegistryChunkGlobalHeader, end, fail);
887 *filter_env_hash = hdr->filter_env_hash;
892 GST_WARNING ("Reading global header failed");