gtkD/srcgstreamer/gstreamer/Plugin.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = GstPlugin.html
  26  * outPack = gstreamer
  27  * outFile = Plugin
  28  * strct   = GstPlugin
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = Plugin
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gst_plugin_
  40  *      - gst_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - glib.Str
  46  *      - glib.Module
  47  *      - glib.ErrorG
  48  *      - glib.ListG
  49  * structWrap:
  50  *      - GList* -> ListG
  51  *      - GModule* -> Module
  52  *      - GstPlugin* -> Plugin
  53  * module aliases:
  54  * local aliases:
  55  */
  56
  57 module gstreamer.Plugin;
  58
  59 private import gstreamerc.gstreamertypes;
  60
  61 private import gstreamerc.gstreamer;
  62
  63 private import glib.Str;
  64 private import glib.Module;
  65 private import glib.ErrorG;
  66 private import glib.ListG;
  67
  68
  69
  70 /**
  71  * Description
  72  * GStreamer is extensible, so GstElement instances can be loaded at runtime.
  73  * A plugin system can provide one or more of the basic
  74  * GStreamer GstPluginFeature subclasses.
  75  * A plugin should export a symbol plugin_desc that is a
  76  * struct of type GstPluginDesc.
  77  * the plugin loader will check the version of the core library the plugin was
  78  * linked against and will create a new GstPlugin. It will then call the
  79  * GstPluginInitFunc function that was provided in the plugin_desc.
  80  * Once you have a handle to a GstPlugin (e.g. from the GstRegistryPool), you
  81  * can add any object that subclasses GstPluginFeature.
  82  * Use gst_plugin_find_feature() and gst_plugin_get_feature_list() to find
  83  * features in a plugin.
  84  * Usually plugins are always automaticlly loaded so you don't need to call
  85  * gst_plugin_load() explicitly to bring it into memory. There are options to
  86  * statically link plugins to an app or even use GStreamer without a plugin
  87  * repository in which case gst_plugin_load() can be needed to bring the plugin
  88  * into memory.
  89  */
  90 private import gstreamer.ObjectGst;
  91 public class Plugin : ObjectGst
  92 {
  93
  94         /** the main Gtk struct */
  95         protected GstPlugin* gstPlugin;
  96
  97
  98         public GstPlugin* getPluginStruct()
  99         {
 100                 return gstPlugin;
 101         }
 102
 103
 104         /** the main Gtk struct as a void* */
 105         protected void* getStruct()
 106         {
 107                 return cast(void*)gstPlugin;
 108         }
 109
 110         /**
 111          * Sets our main struct and passes it to the parent class
 112          */
 113         public this (GstPlugin* gstPlugin)
 114         {
 115                 super(cast(GstObject*)gstPlugin);
 116                 this.gstPlugin = gstPlugin;
 117         }
 118
 119         /**
 120          */
 121
 122         /**
 123          * Get the error quark.
 124          * Returns:
 125          *  The error quark used in GError messages
 126          */
 127         public static GQuark errorQuark()
 128         {
 129                 // GQuark gst_plugin_error_quark (void);
 130                 return gst_plugin_error_quark();
 131         }
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142         /**
 143          * Get the short name of the plugin
 144          * plugin:
 145          *  plugin to get the name of
 146          * Returns:
 147          *  the name of the plugin
 148          */
 149         public char[] getName()
 150         {
 151                 // const gchar* gst_plugin_get_name (GstPlugin *plugin);
 152                 return Str.toString(gst_plugin_get_name(gstPlugin) );
 153         }
 154
 155         /**
 156          * Get the long descriptive name of the plugin
 157          * plugin:
 158          *  plugin to get long name of
 159          * Returns:
 160          *  the long name of the plugin
 161          */
 162         public char[] getDescription()
 163         {
 164                 // const gchar* gst_plugin_get_description (GstPlugin *plugin);
 165                 return Str.toString(gst_plugin_get_description(gstPlugin) );
 166         }
 167
 168         /**
 169          * get the filename of the plugin
 170          * plugin:
 171          *  plugin to get the filename of
 172          * Returns:
 173          *  the filename of the plugin
 174          */
 175         public char[] getFilename()
 176         {
 177                 // const gchar* gst_plugin_get_filename (GstPlugin *plugin);
 178                 return Str.toString(gst_plugin_get_filename(gstPlugin) );
 179         }
 180
 181         /**
 182          * get the license of the plugin
 183          * plugin:
 184          *  plugin to get the license of
 185          * Returns:
 186          *  the license of the plugin
 187          */
 188         public char[] getLicense()
 189         {
 190                 // const gchar* gst_plugin_get_license (GstPlugin *plugin);
 191                 return Str.toString(gst_plugin_get_license(gstPlugin) );
 192         }
 193
 194         /**
 195          * get the package the plugin belongs to.
 196          * plugin:
 197          *  plugin to get the package of
 198          * Returns:
 199          *  the package of the plugin
 200          */
 201         public char[] getPackage()
 202         {
 203                 // const gchar* gst_plugin_get_package (GstPlugin *plugin);
 204                 return Str.toString(gst_plugin_get_package(gstPlugin) );
 205         }
 206
 207         /**
 208          * get the URL where the plugin comes from
 209          * plugin:
 210          *  plugin to get the origin of
 211          * Returns:
 212          *  the origin of the plugin
 213          */
 214         public char[] getOrigin()
 215         {
 216                 // const gchar* gst_plugin_get_origin (GstPlugin *plugin);
 217                 return Str.toString(gst_plugin_get_origin(gstPlugin) );
 218         }
 219
 220         /**
 221          * get the source module the plugin belongs to.
 222          * plugin:
 223          *  plugin to get the source of
 224          * Returns:
 225          *  the source of the plugin
 226          */
 227         public char[] getSource()
 228         {
 229                 // const gchar* gst_plugin_get_source (GstPlugin *plugin);
 230                 return Str.toString(gst_plugin_get_source(gstPlugin) );
 231         }
 232
 233         /**
 234          * get the version of the plugin
 235          * plugin:
 236          *  plugin to get the version of
 237          * Returns:
 238          *  the version of the plugin
 239          */
 240         public char[] getVersion()
 241         {
 242                 // const gchar* gst_plugin_get_version (GstPlugin *plugin);
 243                 return Str.toString(gst_plugin_get_version(gstPlugin) );
 244         }
 245
 246         /**
 247          * Gets the GModule of the plugin. If the plugin isn't loaded yet, NULL is
 248          * returned.
 249          * plugin:
 250          *  plugin to query
 251          * Returns:
 252          *  module belonging to the plugin or NULL if the plugin isn't
 253          *  loaded yet.
 254          */
 255         public Module getModule()
 256         {
 257                 // GModule* gst_plugin_get_module (GstPlugin *plugin);
 258                 return new Module( gst_plugin_get_module(gstPlugin) );
 259         }
 260
 261         /**
 262          * queries if the plugin is loaded into memory
 263          * plugin:
 264          *  plugin to query
 265          * Returns:
 266          *  TRUE is loaded, FALSE otherwise
 267          */
 268         public int isLoaded()
 269         {
 270                 // gboolean gst_plugin_is_loaded (GstPlugin *plugin);
 271                 return gst_plugin_is_loaded(gstPlugin);
 272         }
 273
 274         /**
 275          * A standard filter that returns TRUE when the plugin is of the
 276          * given name.
 277          * plugin:
 278          *  the plugin to check
 279          * name:
 280          *  the name of the plugin
 281          * Returns:
 282          *  TRUE if the plugin is of the given name.
 283          */
 284         public int nameFilter(char[] name)
 285         {
 286                 // gboolean gst_plugin_name_filter (GstPlugin *plugin,  const gchar *name);
 287                 return gst_plugin_name_filter(gstPlugin, Str.toStringz(name));
 288         }
 289
 290         /**
 291          * Loads the given plugin and refs it. Caller needs to unref after use.
 292          * filename:
 293          *  the plugin filename to load
 294          * error:
 295          *  pointer to a NULL-valued GError
 296          * Returns:
 297          *  a reference to the existing loaded GstPlugin, a reference to the
 298          * newly-loaded GstPlugin, or NULL if an error occurred.
 299          */
 300         public static Plugin loadFile(char[] filename, GError** error)
 301         {
 302                 // GstPlugin* gst_plugin_load_file (const gchar *filename,  GError **error);
 303                 return new Plugin( gst_plugin_load_file(Str.toStringz(filename), error) );
 304         }
 305
 306         /**
 307          * Loads plugin. Note that the *return value* is the loaded plugin; plugin is
 308          * untouched. The normal use pattern of this function goes like this:
 309          * GstPlugin *loaded_plugin;
 310          * loaded_plugin = gst_plugin_load (plugin);
 311          * // presumably, we're no longer interested in the potentially-unloaded plugin
 312          * gst_object_unref (plugin);
 313          * plugin = loaded_plugin;
 314          * plugin:
 315          *  plugin to load
 316          * Returns:
 317          *  A reference to a loaded plugin, or NULL on error.
 318          */
 319         public Plugin load()
 320         {
 321                 // GstPlugin* gst_plugin_load (GstPlugin *plugin);
 322                 return new Plugin( gst_plugin_load(gstPlugin) );
 323         }
 324
 325         /**
 326          * Load the named plugin. Refs the plugin.
 327          * name:
 328          *  name of plugin to load
 329          * Returns:
 330          *  A reference to a loaded plugin, or NULL on error.
 331          */
 332         public static Plugin loadByName(char[] name)
 333         {
 334                 // GstPlugin* gst_plugin_load_by_name (const gchar *name);
 335                 return new Plugin( gst_plugin_load_by_name(Str.toStringz(name)) );
 336         }
 337
 338         /**
 339          * Unrefs each member of list, then frees the list.
 340          * list:
 341          *  list of GstPlugin
 342          * See Also
 343          * GstPluginFeature, GstElementFactory
 344          */
 345         public static void listFree(ListG list)
 346         {
 347                 // void gst_plugin_list_free (GList *list);
 348                 gst_plugin_list_free((list is null) ? null : list.getListGStruct());
 349         }
 350 }