meta: add metadata flags
[platform/upstream/gstreamer.git] / gst / gstregistrychunks.c
1 /* GStreamer
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>
7  *
8  * gstregistrychunks.c: GstRegistryChunk helper for serialising/deserialising
9  * plugin entries and features.
10  *
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.
15  *
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.
20  *
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.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 #  include "config.h"
29 #endif
30
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>
40
41 #include <gst/gstregistrychunks.h>
42
43 #define GST_CAT_DEFAULT GST_CAT_REGISTRY
44
45 /* count string length, but return -1 if we hit the eof */
46 static gint
47 _strnlen (const gchar * str, gint maxlen)
48 {
49   gint len = 0;
50
51   while (G_LIKELY (len < maxlen)) {
52     if (G_UNLIKELY (str[len] == '\0'))
53       return len;
54     len++;
55   }
56   return -1;
57 }
58
59 /* Macros */
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)); \
65     goto error_label; \
66   } \
67   outptr = (element *) inptr; \
68   inptr += sizeof (element); \
69 }G_STMT_END
70
71 #define unpack_const_string(inptr, outptr, endptr, error_label) G_STMT_START{\
72   gint _len = _strnlen (inptr, (endptr-inptr)); \
73   if (_len == -1) \
74     goto error_label; \
75   outptr = g_intern_string ((const gchar *)inptr); \
76   inptr += _len + 1; \
77 }G_STMT_END
78
79 #define unpack_string(inptr, outptr, endptr, error_label)  G_STMT_START{\
80   gint _len = _strnlen (inptr, (endptr-inptr)); \
81   if (_len == -1) \
82     goto error_label; \
83   outptr = g_memdup ((gconstpointer)inptr, _len + 1); \
84   inptr += _len + 1; \
85 }G_STMT_END
86
87 #define unpack_string_nocopy(inptr, outptr, endptr, error_label)  G_STMT_START{\
88   gint _len = _strnlen (inptr, (endptr-inptr)); \
89   if (_len == -1) \
90     goto error_label; \
91   outptr = (const gchar *)inptr; \
92   inptr += _len + 1; \
93 }G_STMT_END
94
95 #define ALIGNMENT            (sizeof (void *))
96 #define alignment(_address)  (gsize)_address%ALIGNMENT
97 #define align(_ptr)          _ptr += (( alignment(_ptr) == 0) ? 0 : ALIGNMENT-alignment(_ptr))
98
99 void
100 _priv_gst_registry_chunk_free (GstRegistryChunk * chunk)
101 {
102   if (!(chunk->flags & GST_REGISTRY_CHUNK_FLAG_CONST)) {
103     if ((chunk->flags & GST_REGISTRY_CHUNK_FLAG_MALLOC))
104       g_free (chunk->data);
105     else
106       g_slice_free1 (chunk->size, chunk->data);
107   }
108   g_slice_free (GstRegistryChunk, chunk);
109 }
110
111 /*
112  * gst_registry_chunks_save_const_string:
113  *
114  * Store a const string in a binary chunk.
115  *
116  * Returns: %TRUE for success
117  */
118 inline static gboolean
119 gst_registry_chunks_save_const_string (GList ** list, const gchar * str)
120 {
121   GstRegistryChunk *chunk;
122
123   if (G_UNLIKELY (str == NULL)) {
124     GST_ERROR ("unexpected NULL string in plugin or plugin feature data");
125     str = "";
126   }
127
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);
134   return TRUE;
135 }
136
137 /*
138  * gst_registry_chunks_save_string:
139  *
140  * Store a string in a binary chunk.
141  *
142  * Returns: %TRUE for success
143  */
144 inline static gboolean
145 gst_registry_chunks_save_string (GList ** list, gchar * str)
146 {
147   GstRegistryChunk *chunk;
148
149   chunk = g_slice_new (GstRegistryChunk);
150   chunk->data = str;
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);
155   return TRUE;
156 }
157
158 /*
159  * gst_registry_chunks_save_data:
160  *
161  * Store some data in a binary chunk.
162  *
163  * Returns: the initialized chunk
164  */
165 inline static GstRegistryChunk *
166 gst_registry_chunks_make_data (gpointer data, gulong size)
167 {
168   GstRegistryChunk *chunk;
169
170   chunk = g_slice_new (GstRegistryChunk);
171   chunk->data = data;
172   chunk->size = size;
173   chunk->flags = GST_REGISTRY_CHUNK_FLAG_NONE;
174   chunk->align = TRUE;
175   return chunk;
176 }
177
178
179 /*
180  * gst_registry_chunks_save_pad_template:
181  *
182  * Store pad_templates in binary chunks.
183  *
184  * Returns: %TRUE for success
185  */
186 static gboolean
187 gst_registry_chunks_save_pad_template (GList ** list,
188     GstStaticPadTemplate * template)
189 {
190   GstRegistryChunkPadTemplate *pt;
191   GstRegistryChunk *chk;
192
193   pt = g_slice_new (GstRegistryChunkPadTemplate);
194   chk =
195       gst_registry_chunks_make_data (pt, sizeof (GstRegistryChunkPadTemplate));
196
197   pt->presence = template->presence;
198   pt->direction = template->direction;
199
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);
204
205   *list = g_list_prepend (*list, chk);
206
207   return TRUE;
208 }
209
210 #define VALIDATE_UTF8(__details, __entry)                                   \
211 G_STMT_START {                                                              \
212   if (!g_utf8_validate (__details->__entry, -1, NULL)) {                    \
213     g_warning ("Invalid UTF-8 in " G_STRINGIFY (__entry) ": %s",            \
214         __details->__entry);                                                \
215     g_free (__details->__entry);                                            \
216     __details->__entry = g_strdup ("[ERROR: invalid UTF-8]");               \
217   }                                                                         \
218 } G_STMT_END
219
220 /*
221  * gst_registry_chunks_save_feature:
222  *
223  * Store features in binary chunks.
224  *
225  * Returns: %TRUE for success
226  */
227 static gboolean
228 gst_registry_chunks_save_feature (GList ** list, GstPluginFeature * feature)
229 {
230   const gchar *type_name = g_type_name (G_OBJECT_TYPE (feature));
231   GstRegistryChunkPluginFeature *pf = NULL;
232   GstRegistryChunk *chk = NULL;
233   GList *walk;
234
235   if (!type_name) {
236     GST_ERROR ("NULL feature type_name, aborting.");
237     return FALSE;
238   }
239
240   if (GST_IS_ELEMENT_FACTORY (feature)) {
241     GstRegistryChunkElementFactory *ef;
242     GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
243
244     /* Initialize with zeroes because of struct padding and
245      * valgrind complaining about copying unitialized memory
246      */
247     ef = g_slice_new0 (GstRegistryChunkElementFactory);
248     chk =
249         gst_registry_chunks_make_data (ef,
250         sizeof (GstRegistryChunkElementFactory));
251     ef->npadtemplates = ef->ninterfaces = ef->nuriprotocols = 0;
252     pf = (GstRegistryChunkPluginFeature *) ef;
253
254     /* save interfaces */
255     for (walk = factory->interfaces; walk;
256         walk = g_list_next (walk), ef->ninterfaces++) {
257       gst_registry_chunks_save_const_string (list, (gchar *) walk->data);
258     }
259     GST_DEBUG ("Feature %s: saved %d interfaces %d pad templates",
260         GST_OBJECT_NAME (feature), ef->ninterfaces, ef->npadtemplates);
261
262     /* save uritypes */
263     if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {
264       if (factory->uri_protocols && *factory->uri_protocols) {
265         GstRegistryChunk *subchk;
266         gchar **protocol;
267
268         subchk =
269             gst_registry_chunks_make_data (&factory->uri_type,
270             sizeof (factory->uri_type));
271         subchk->flags = GST_REGISTRY_CHUNK_FLAG_CONST;
272
273         protocol = factory->uri_protocols;
274         while (*protocol) {
275           gst_registry_chunks_save_const_string (list, *protocol++);
276           ef->nuriprotocols++;
277         }
278         *list = g_list_prepend (*list, subchk);
279         GST_DEBUG ("Saved %d UriTypes", ef->nuriprotocols);
280       } else {
281         g_warning ("GStreamer feature '%s' is URI handler but does not provide"
282             " any protocols it can handle", GST_OBJECT_NAME (feature));
283       }
284     }
285
286     /* save pad-templates */
287     for (walk = factory->staticpadtemplates; walk;
288         walk = g_list_next (walk), ef->npadtemplates++) {
289       GstStaticPadTemplate *template = walk->data;
290
291       if (!gst_registry_chunks_save_pad_template (list, template)) {
292         GST_ERROR ("Can't fill pad template, aborting.");
293         goto fail;
294       }
295     }
296
297     /* pack element metadata strings */
298     gst_registry_chunks_save_string (list,
299         gst_structure_to_string (factory->metadata));
300   } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
301     GstRegistryChunkTypeFindFactory *tff;
302     GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
303     gchar *str;
304
305     /* Initialize with zeroes because of struct padding and
306      * valgrind complaining about copying unitialized memory
307      */
308     tff = g_slice_new0 (GstRegistryChunkTypeFindFactory);
309     chk =
310         gst_registry_chunks_make_data (tff,
311         sizeof (GstRegistryChunkTypeFindFactory));
312     tff->nextensions = 0;
313     pf = (GstRegistryChunkPluginFeature *) tff;
314
315     /* save extensions */
316     if (factory->extensions) {
317       while (factory->extensions[tff->nextensions]) {
318         gst_registry_chunks_save_const_string (list,
319             factory->extensions[tff->nextensions++]);
320       }
321     }
322     /* save caps */
323     if (factory->caps) {
324       /* we copy the caps here so we can simplify them before saving. This
325        * is a lot faster when loading them later on */
326       GstCaps *copy = gst_caps_copy (factory->caps);
327
328       gst_caps_do_simplify (copy);
329       str = gst_caps_to_string (copy);
330       gst_caps_unref (copy);
331       gst_registry_chunks_save_string (list, str);
332     } else {
333       gst_registry_chunks_save_const_string (list, "");
334     }
335   } else if (GST_IS_INDEX_FACTORY (feature)) {
336     GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
337
338     pf = g_slice_new (GstRegistryChunkPluginFeature);
339     chk =
340         gst_registry_chunks_make_data (pf,
341         sizeof (GstRegistryChunkPluginFeature));
342
343     /* pack element factory strings */
344     gst_registry_chunks_save_const_string (list, factory->longdesc);
345   } else {
346     GST_WARNING ("unhandled feature type '%s'", type_name);
347   }
348
349   if (pf) {
350     pf->rank = feature->rank;
351     *list = g_list_prepend (*list, chk);
352
353     /* pack plugin feature strings */
354     gst_registry_chunks_save_const_string (list, GST_OBJECT_NAME (feature));
355     gst_registry_chunks_save_const_string (list, (gchar *) type_name);
356
357     return TRUE;
358   }
359
360   /* Errors */
361 fail:
362   g_free (chk);
363   g_free (pf);
364   return FALSE;
365 }
366
367 static gboolean
368 gst_registry_chunks_save_plugin_dep (GList ** list, GstPluginDep * dep)
369 {
370   GstRegistryChunkDep *ed;
371   GstRegistryChunk *chk;
372   gchar **s;
373
374   ed = g_slice_new (GstRegistryChunkDep);
375   chk = gst_registry_chunks_make_data (ed, sizeof (GstRegistryChunkDep));
376
377   ed->flags = dep->flags;
378   ed->n_env_vars = 0;
379   ed->n_paths = 0;
380   ed->n_names = 0;
381
382   ed->env_hash = dep->env_hash;
383   ed->stat_hash = dep->stat_hash;
384
385   for (s = dep->env_vars; s != NULL && *s != NULL; ++s, ++ed->n_env_vars)
386     gst_registry_chunks_save_string (list, g_strdup (*s));
387
388   for (s = dep->paths; s != NULL && *s != NULL; ++s, ++ed->n_paths)
389     gst_registry_chunks_save_string (list, g_strdup (*s));
390
391   for (s = dep->names; s != NULL && *s != NULL; ++s, ++ed->n_names)
392     gst_registry_chunks_save_string (list, g_strdup (*s));
393
394   *list = g_list_prepend (*list, chk);
395
396   GST_LOG ("Saved external plugin dependency");
397   return TRUE;
398 }
399
400 /*
401  * _priv_gst_registry_chunks_save_plugin:
402  *
403  * Adapt a GstPlugin to our GstRegistryChunkPluginElement structure, and
404  * prepend it as a GstRegistryChunk in the provided list.
405  *
406  */
407 gboolean
408 _priv_gst_registry_chunks_save_plugin (GList ** list, GstRegistry * registry,
409     GstPlugin * plugin)
410 {
411   GstRegistryChunkPluginElement *pe;
412   GstRegistryChunk *chk;
413   GList *plugin_features = NULL;
414   GList *walk;
415
416   pe = g_slice_new (GstRegistryChunkPluginElement);
417   chk =
418       gst_registry_chunks_make_data (pe,
419       sizeof (GstRegistryChunkPluginElement));
420
421   pe->file_size = plugin->file_size;
422   pe->file_mtime = plugin->file_mtime;
423   pe->nfeatures = 0;
424   pe->n_deps = 0;
425
426   /* pack external deps */
427   for (walk = plugin->priv->deps; walk != NULL; walk = walk->next) {
428     if (!gst_registry_chunks_save_plugin_dep (list, walk->data)) {
429       GST_ERROR ("Could not save external plugin dependency, aborting.");
430       goto fail;
431     }
432     ++pe->n_deps;
433   }
434
435   /* pack plugin features */
436   plugin_features =
437       gst_registry_get_feature_list_by_plugin (registry, plugin->desc.name);
438   for (walk = plugin_features; walk; walk = g_list_next (walk), pe->nfeatures++) {
439     GstPluginFeature *feature = GST_PLUGIN_FEATURE (walk->data);
440
441     if (!gst_registry_chunks_save_feature (list, feature)) {
442       GST_ERROR ("Can't fill plugin feature, aborting.");
443       goto fail;
444     }
445   }
446
447   gst_plugin_feature_list_free (plugin_features);
448
449   /* pack cache data */
450   if (plugin->priv->cache_data) {
451     gchar *cache_str = gst_structure_to_string (plugin->priv->cache_data);
452     gst_registry_chunks_save_string (list, cache_str);
453   } else {
454     gst_registry_chunks_save_const_string (list, "");
455   }
456
457   /* pack plugin element strings */
458   gst_registry_chunks_save_const_string (list,
459       (plugin->desc.release_datetime) ? plugin->desc.release_datetime : "");
460   gst_registry_chunks_save_const_string (list, plugin->desc.origin);
461   gst_registry_chunks_save_const_string (list, plugin->desc.package);
462   gst_registry_chunks_save_const_string (list, plugin->desc.source);
463   gst_registry_chunks_save_const_string (list, plugin->desc.license);
464   gst_registry_chunks_save_const_string (list, plugin->desc.version);
465   gst_registry_chunks_save_const_string (list, plugin->filename);
466   gst_registry_chunks_save_const_string (list, plugin->desc.description);
467   gst_registry_chunks_save_const_string (list, plugin->desc.name);
468
469   *list = g_list_prepend (*list, chk);
470
471   GST_DEBUG ("Found %d features in plugin \"%s\"", pe->nfeatures,
472       plugin->desc.name);
473   return TRUE;
474
475   /* Errors */
476 fail:
477   gst_plugin_feature_list_free (plugin_features);
478   g_free (chk);
479   g_free (pe);
480   return FALSE;
481 }
482
483 /*
484  * gst_registry_chunks_load_pad_template:
485  *
486  * Make a new GstStaticPadTemplate from current GstRegistryChunkPadTemplate
487  * structure.
488  *
489  * Returns: new GstStaticPadTemplate
490  */
491 static gboolean
492 gst_registry_chunks_load_pad_template (GstElementFactory * factory, gchar ** in,
493     gchar * end)
494 {
495   GstRegistryChunkPadTemplate *pt;
496   GstStaticPadTemplate *template = NULL;
497
498   align (*in);
499   GST_DEBUG ("Reading/casting for GstRegistryChunkPadTemplate at address %p",
500       *in);
501   unpack_element (*in, pt, GstRegistryChunkPadTemplate, end, fail);
502
503   template = g_slice_new (GstStaticPadTemplate);
504   template->presence = pt->presence;
505   template->direction = (GstPadDirection) pt->direction;
506   template->static_caps.caps.mini_object.refcount = 0;
507
508   /* unpack pad template strings */
509   unpack_const_string (*in, template->name_template, end, fail);
510   unpack_const_string (*in, template->static_caps.string, end, fail);
511
512   __gst_element_factory_add_static_pad_template (factory, template);
513   GST_DEBUG ("Added pad_template %s", template->name_template);
514
515   return TRUE;
516 fail:
517   GST_INFO ("Reading pad template failed");
518   if (template)
519     g_slice_free (GstStaticPadTemplate, template);
520   return FALSE;
521 }
522
523 /*
524  * gst_registry_chunks_load_feature:
525  *
526  * Make a new GstPluginFeature from current binary plugin feature structure
527  *
528  * Returns: new GstPluginFeature
529  */
530 static gboolean
531 gst_registry_chunks_load_feature (GstRegistry * registry, gchar ** in,
532     gchar * end, GstPlugin * plugin)
533 {
534   GstRegistryChunkPluginFeature *pf = NULL;
535   GstPluginFeature *feature = NULL;
536   const gchar *const_str, *type_name;
537   const gchar *feature_name;
538   const gchar *plugin_name;
539   gchar *str;
540   GType type;
541   guint i;
542
543   plugin_name = plugin->desc.name;
544
545   /* unpack plugin feature strings */
546   unpack_string_nocopy (*in, type_name, end, fail);
547
548   if (G_UNLIKELY (!type_name)) {
549     GST_ERROR ("No feature type name");
550     return FALSE;
551   }
552
553   /* unpack more plugin feature strings */
554   unpack_string_nocopy (*in, feature_name, end, fail);
555
556   GST_DEBUG ("Plugin '%s' feature '%s' typename : '%s'", plugin_name,
557       feature_name, type_name);
558
559   if (G_UNLIKELY (!(type = g_type_from_name (type_name)))) {
560     GST_ERROR ("Unknown type from typename '%s' for plugin '%s'", type_name,
561         plugin_name);
562     return FALSE;
563   }
564   if (G_UNLIKELY ((feature = g_object_newv (type, 0, NULL)) == NULL)) {
565     GST_ERROR ("Can't create feature from type");
566     return FALSE;
567   }
568   gst_plugin_feature_set_name (feature, feature_name);
569
570   if (G_UNLIKELY (!GST_IS_PLUGIN_FEATURE (feature))) {
571     GST_ERROR ("typename : '%s' is not a plugin feature", type_name);
572     goto fail;
573   }
574
575   if (GST_IS_ELEMENT_FACTORY (feature)) {
576     GstRegistryChunkElementFactory *ef;
577     guint n;
578     GstElementFactory *factory = GST_ELEMENT_FACTORY_CAST (feature);
579     gchar *str;
580     const gchar *meta_data_str;
581
582     align (*in);
583     GST_LOG ("Reading/casting for GstRegistryChunkElementFactory at address %p",
584         *in);
585     unpack_element (*in, ef, GstRegistryChunkElementFactory, end, fail);
586     pf = (GstRegistryChunkPluginFeature *) ef;
587
588     /* unpack element factory strings */
589     unpack_string_nocopy (*in, meta_data_str, end, fail);
590     if (meta_data_str && *meta_data_str) {
591       factory->metadata = gst_structure_from_string (meta_data_str, NULL);
592       if (!factory->metadata) {
593         GST_ERROR
594             ("Error when trying to deserialize structure for metadata '%s'",
595             meta_data_str);
596         goto fail;
597       }
598     }
599     n = ef->npadtemplates;
600     GST_DEBUG ("Element factory : npadtemplates=%d", n);
601
602     /* load pad templates */
603     for (i = 0; i < n; i++) {
604       if (G_UNLIKELY (!gst_registry_chunks_load_pad_template (factory, in,
605                   end))) {
606         GST_ERROR ("Error while loading binary pad template");
607         goto fail;
608       }
609     }
610
611     /* load uritypes */
612     if (G_UNLIKELY ((n = ef->nuriprotocols))) {
613       GST_DEBUG ("Reading %d UriTypes at address %p", n, *in);
614
615       align (*in);
616       factory->uri_type = *((guint *) * in);
617       *in += sizeof (factory->uri_type);
618       /*unpack_element(*in, &factory->uri_type, factory->uri_type, end, fail); */
619
620       factory->uri_protocols = g_new0 (gchar *, n + 1);
621       for (i = 0; i < n; i++) {
622         unpack_string (*in, str, end, fail);
623         factory->uri_protocols[i] = str;
624       }
625     }
626     /* load interfaces */
627     if (G_UNLIKELY ((n = ef->ninterfaces))) {
628       GST_DEBUG ("Reading %d Interfaces at address %p", n, *in);
629       for (i = 0; i < n; i++) {
630         unpack_string_nocopy (*in, const_str, end, fail);
631         __gst_element_factory_add_interface (factory, const_str);
632       }
633     }
634   } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
635     GstRegistryChunkTypeFindFactory *tff;
636     GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
637
638     align (*in);
639     GST_DEBUG
640         ("Reading/casting for GstRegistryChunkPluginFeature at address %p",
641         *in);
642     unpack_element (*in, tff, GstRegistryChunkTypeFindFactory, end, fail);
643     pf = (GstRegistryChunkPluginFeature *) tff;
644
645     /* load typefinder caps */
646     unpack_string_nocopy (*in, const_str, end, fail);
647     if (const_str != NULL && *const_str != '\0')
648       factory->caps = gst_caps_from_string (const_str);
649     else
650       factory->caps = NULL;
651
652     /* load extensions */
653     if (tff->nextensions) {
654       GST_DEBUG ("Reading %d Typefind extensions at address %p",
655           tff->nextensions, *in);
656       factory->extensions = g_new0 (gchar *, tff->nextensions + 1);
657       /* unpack in reverse order to maintain the correct order */
658       for (i = tff->nextensions; i > 0; i--) {
659         unpack_string (*in, str, end, fail);
660         factory->extensions[i - 1] = str;
661       }
662     }
663   } else if (GST_IS_INDEX_FACTORY (feature)) {
664     GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
665
666     align (*in);
667     GST_DEBUG
668         ("Reading/casting for GstRegistryChunkPluginFeature at address %p",
669         *in);
670     unpack_element (*in, pf, GstRegistryChunkPluginFeature, end, fail);
671
672     /* unpack index factory strings */
673     unpack_string (*in, factory->longdesc, end, fail);
674   } else {
675     GST_WARNING ("unhandled factory type : %s", G_OBJECT_TYPE_NAME (feature));
676     goto fail;
677   }
678
679   feature->rank = pf->rank;
680
681   feature->plugin_name = plugin_name;
682   feature->plugin = plugin;
683   g_object_add_weak_pointer ((GObject *) plugin,
684       (gpointer *) & feature->plugin);
685
686   gst_registry_add_feature (registry, feature);
687   GST_DEBUG ("Added feature %s, plugin %p %s", GST_OBJECT_NAME (feature),
688       plugin, plugin_name);
689
690   return TRUE;
691
692   /* Errors */
693 fail:
694   GST_INFO ("Reading plugin feature failed");
695   if (feature) {
696     if (GST_IS_OBJECT (feature))
697       gst_object_unref (feature);
698     else
699       g_object_unref (feature);
700   }
701   return FALSE;
702 }
703
704 static gchar **
705 gst_registry_chunks_load_plugin_dep_strv (gchar ** in, gchar * end, guint n)
706 {
707   gchar **arr;
708
709   if (n == 0)
710     return NULL;
711
712   arr = g_new0 (gchar *, n + 1);
713   while (n > 0) {
714     unpack_string (*in, arr[n - 1], end, fail);
715     --n;
716   }
717   return arr;
718 fail:
719   GST_INFO ("Reading plugin dependency strings failed");
720   return NULL;
721 }
722
723 static gboolean
724 gst_registry_chunks_load_plugin_dep (GstPlugin * plugin, gchar ** in,
725     gchar * end)
726 {
727   GstPluginDep *dep;
728   GstRegistryChunkDep *d;
729   gchar **s;
730
731   align (*in);
732   GST_LOG_OBJECT (plugin, "Unpacking GstRegistryChunkDep from %p", *in);
733   unpack_element (*in, d, GstRegistryChunkDep, end, fail);
734
735   dep = g_slice_new (GstPluginDep);
736
737   dep->env_hash = d->env_hash;
738   dep->stat_hash = d->stat_hash;
739
740   dep->flags = (GstPluginDependencyFlags) d->flags;
741
742   dep->names = gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_names);
743   dep->paths = gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_paths);
744   dep->env_vars =
745       gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_env_vars);
746
747   plugin->priv->deps = g_list_append (plugin->priv->deps, dep);
748
749   GST_DEBUG_OBJECT (plugin, "Loaded external plugin dependency from registry: "
750       "env_hash: %08x, stat_hash: %08x", dep->env_hash, dep->stat_hash);
751   for (s = dep->env_vars; s != NULL && *s != NULL; ++s)
752     GST_LOG_OBJECT (plugin, " evar: %s", *s);
753   for (s = dep->paths; s != NULL && *s != NULL; ++s)
754     GST_LOG_OBJECT (plugin, " path: %s", *s);
755   for (s = dep->names; s != NULL && *s != NULL; ++s)
756     GST_LOG_OBJECT (plugin, " name: %s", *s);
757
758   return TRUE;
759 fail:
760   GST_INFO ("Reading plugin dependency failed");
761   return FALSE;
762 }
763
764
765 /*
766  * _priv_gst_registry_chunks_load_plugin:
767  *
768  * Make a new GstPlugin from current GstRegistryChunkPluginElement structure
769  * and add it to the GstRegistry. Return an offset to the next
770  * GstRegistryChunkPluginElement structure.
771  */
772 gboolean
773 _priv_gst_registry_chunks_load_plugin (GstRegistry * registry, gchar ** in,
774     gchar * end, GstPlugin ** out_plugin)
775 {
776 #ifndef GST_DISABLE_GST_DEBUG
777   gchar *start = *in;
778 #endif
779   GstRegistryChunkPluginElement *pe;
780   const gchar *cache_str = NULL;
781   GstPlugin *plugin = NULL;
782   guint i, n;
783
784   align (*in);
785   GST_LOG ("Reading/casting for GstRegistryChunkPluginElement at address %p",
786       *in);
787   unpack_element (*in, pe, GstRegistryChunkPluginElement, end, fail);
788
789   plugin = g_object_newv (GST_TYPE_PLUGIN, 0, NULL);
790
791   /* TODO: also set GST_PLUGIN_FLAG_CONST */
792   plugin->flags |= GST_PLUGIN_FLAG_CACHED;
793   plugin->file_mtime = pe->file_mtime;
794   plugin->file_size = pe->file_size;
795
796   /* unpack plugin element strings */
797   unpack_const_string (*in, plugin->desc.name, end, fail);
798   unpack_const_string (*in, plugin->desc.description, end, fail);
799   unpack_string (*in, plugin->filename, end, fail);
800   unpack_const_string (*in, plugin->desc.version, end, fail);
801   unpack_const_string (*in, plugin->desc.license, end, fail);
802   unpack_const_string (*in, plugin->desc.source, end, fail);
803   unpack_const_string (*in, plugin->desc.package, end, fail);
804   unpack_const_string (*in, plugin->desc.origin, end, fail);
805   unpack_const_string (*in, plugin->desc.release_datetime, end, fail);
806
807   GST_LOG ("read strings for name='%s'", plugin->desc.name);
808   GST_LOG ("  desc.description='%s'", plugin->desc.description);
809   GST_LOG ("  filename='%s'", plugin->filename);
810   GST_LOG ("  desc.version='%s'", plugin->desc.version);
811   GST_LOG ("  desc.license='%s'", plugin->desc.license);
812   GST_LOG ("  desc.source='%s'", plugin->desc.source);
813   GST_LOG ("  desc.package='%s'", plugin->desc.package);
814   GST_LOG ("  desc.origin='%s'", plugin->desc.origin);
815   GST_LOG ("  desc.datetime=%s", plugin->desc.release_datetime);
816
817   if (plugin->desc.release_datetime[0] == '\0')
818     plugin->desc.release_datetime = NULL;
819
820   /* unpack cache data */
821   unpack_string_nocopy (*in, cache_str, end, fail);
822   if (cache_str != NULL && *cache_str != '\0')
823     plugin->priv->cache_data = gst_structure_from_string (cache_str, NULL);
824
825   /* If the license string is 'BLACKLIST', mark this as a blacklisted
826    * plugin */
827   if (strcmp (plugin->desc.license, "BLACKLIST") == 0)
828     plugin->flags |= GST_PLUGIN_FLAG_BLACKLISTED;
829
830   plugin->basename = g_path_get_basename (plugin->filename);
831
832   /* Takes ownership of plugin */
833   gst_registry_add_plugin (registry, plugin);
834   n = pe->nfeatures;
835   GST_DEBUG ("Added plugin '%s' plugin with %d features from binary registry",
836       plugin->desc.name, n);
837
838   /* Load plugin features */
839   for (i = 0; i < n; i++) {
840     if (G_UNLIKELY (!gst_registry_chunks_load_feature (registry, in, end,
841                 plugin))) {
842       GST_ERROR ("Error while loading binary feature for plugin '%s'",
843           GST_STR_NULL (plugin->desc.name));
844       gst_registry_remove_plugin (registry, plugin);
845       goto fail;
846     }
847   }
848
849   /* Load external plugin dependencies */
850   for (i = 0; i < pe->n_deps; ++i) {
851     if (G_UNLIKELY (!gst_registry_chunks_load_plugin_dep (plugin, in, end))) {
852       GST_ERROR_OBJECT (plugin, "Could not read external plugin dependency "
853           "for plugin '%s'", GST_STR_NULL (plugin->desc.name));
854       gst_registry_remove_plugin (registry, plugin);
855       goto fail;
856     }
857   }
858
859   if (out_plugin)
860     *out_plugin = plugin;
861
862   return TRUE;
863
864   /* Errors */
865 fail:
866   GST_INFO ("Reading plugin failed after %u bytes", (guint) (end - start));
867   return FALSE;
868 }
869
870 void
871 _priv_gst_registry_chunks_save_global_header (GList ** list,
872     GstRegistry * registry, guint32 filter_env_hash)
873 {
874   GstRegistryChunkGlobalHeader *hdr;
875   GstRegistryChunk *chk;
876
877   hdr = g_slice_new (GstRegistryChunkGlobalHeader);
878   chk = gst_registry_chunks_make_data (hdr,
879       sizeof (GstRegistryChunkGlobalHeader));
880
881   hdr->filter_env_hash = filter_env_hash;
882
883   *list = g_list_prepend (*list, chk);
884
885   GST_LOG ("Saved global header (filter_env_hash=0x%08x)", filter_env_hash);
886 }
887
888 gboolean
889 _priv_gst_registry_chunks_load_global_header (GstRegistry * registry,
890     gchar ** in, gchar * end, guint32 * filter_env_hash)
891 {
892   GstRegistryChunkGlobalHeader *hdr;
893
894   align (*in);
895   GST_LOG ("Reading/casting for GstRegistryChunkGlobalHeader at %p", *in);
896   unpack_element (*in, hdr, GstRegistryChunkGlobalHeader, end, fail);
897   *filter_env_hash = hdr->filter_env_hash;
898   return TRUE;
899
900   /* Errors */
901 fail:
902   GST_WARNING ("Reading global header failed");
903   return FALSE;
904 }