
                       Ruby-GStreamer 0.1.1 API Reference                       
                       **********************************                       

================================================================================
Module Gst
================================================================================

The GStreamer module.

Functions:

  -------------------
  init(*args) -> true
  -------------------

    Initializes the GStreamer library (using *args), setting up internal path 
    lists, registering built-in elements, and loading standard plugins.
    
    If *args are ommited, GStreamer will be initialized using arguments from the 
    Ruby command line.
    
    This function will always return 'true'.  A RuntimeError exception will be
    raised if GStreamer could not be initialized.

  ------------------
  version -> anArray
  ------------------

    Gets the version number of the GStreamer library, in an array
    of 3 fixnums, which represent major, minor and macro numbers. 
    
    Example: 
    
      # Prints GStreamer version in a String 'major.minor.macro'
      p Gst.version.join('.')

  ------------------------
  has_threads? -> aBoolean
  ------------------------

    Query if GStreamer has threads enabled.

  ---------------------------------
  use_threads(aBoolean) -> aBoolean
  ---------------------------------

    Instructs the core to turn on/off threading. 
    
    When threading is turned off, all thread operations such as 
    mutexes and conditionals are turned into NOPs. 
    Use this if you want absolute minimal overhead and you don't 
    use any threads in the pipeline.
    
    Returns the provided boolean value.

  --------------------------
  set_debug(aBoolean) -> nil
  --------------------------

    Enable or disable debug mode, according to the provided parameter.
    When debug mode is on, Ruby/GStreamer will print various information
    on the screen (as instance, when the GC cames), useful to trace and fix bugs.



================================================================================
Module Gst::Cpu
================================================================================

This module is typically used to enable special optimisations based on the 
features of the CPU.

Included in: Gst.

Functions:

  --------------------
  has_mmx? -> aBoolean
  --------------------

    Checks if the CPU is mmx enabled.

  --------------------
  has_sse? -> aBoolean
  --------------------

    Checks if the CPU is sse enabled.

  -----------------------
  has_mmxext? -> aBoolean
  -----------------------

    Checks if the CPU has extended mmx instructions.

  ----------------------
  has_3dnow? -> aBoolean
  ----------------------

    Checks if the CPU is 3DNOW enabled.



================================================================================
Module Gst::AutoplugFactory
================================================================================

Create autopluggers from a factory.

Inherits from: Gst::PluginFeature.

Included in: Gst.

Instance methods:

  ---------------
  to_s -> aString
  ---------------

    Gets a string representing the factory.



================================================================================
Module Gst::Bin
================================================================================

Base container element.

Inherits from: Gst::Object <- Gst::Element.

Inherited by: Gst::Pipeline.

Included in: Gst.

Class methods:

  ------------------------------
  new(aStringName) -> aBinObject
  ------------------------------

    Creates a named Gst::Bin object.


Instance methods:

  -----------------
  length -> aFixnum
  -----------------

    Returns the number of elements in the container.

  -------------------
  elements -> anArray
  -------------------

    Returns an array of all Gst::Element objects in the container.

  -------------------------
  add(*elements) -> anArray
  -------------------------

    Adds one or more Gst::Element objects to the bin.
    
    Returns an array of all Gst::Element objects in the container.

  ----------------------------
  remove(*elements) -> anArray
  ----------------------------

    Removes one or more Gst::Element objects from the bin, unparenting 
    as well.
    
    Returns an array of all Gst::Element objects in the container.

  ----------------
  remove_all -> []
  ----------------

    Removes all Gst::Element objects in the bin.
    
    Returns an empty array.

  -------------------------------------------
  each_element { |aGstElement| block } -> nil
  -------------------------------------------

    Calls the block for each element in the bin, passing a reference to
    the Gst::Element as parameter.

  -------------------
  iterate -> aBoolean
  -------------------

    Iterates over the elements in this bin.
    
    Returns true if the bin did something useful.  This value can be used
    to determine if the bin is in EOS ("end of stream").

  ---------------------
  clock -> aClockObject
  ---------------------

    Gets the current clock of the (scheduler of the) bin.
    This method overrides Gst::Element#get_clock.

  --------------------
  manager? -> aBoolean
  --------------------

    Checks if the Gst::Bin::FLAG_MANAGER flag is set on the object.

  ------------------------
  schedulable? -> aBoolean
  ------------------------

    Checks if the Gst::Bin::FLAG_SCHEDULABLE flag is set on the object.

  ------------------------------
  prefers_cothreads? -> aBoolean
  ------------------------------

    Checks if the Gst::Bin::FLAG_PREFER_COTHREADS flag is set on the object.

  ----------------------------
  has_fixed_clock? -> aBoolean
  ----------------------------

    Checks if the Gst::Bin::FLAG_FIXED_CLOCK flag is set on the object.

  -----------
  clear -> []
  -----------

    Synonym for Gst::Bin#remove_all.

  ---------------
  size -> aFixnum
  ---------------

    Synonym for Gst::Bin#length.


Constants:

  ------------
  FLAG_MANAGER
  ------------

    This bin is a manager of child elements, i.e. a Gst::Pipeline or
    a Gst::Thread.

  ----------------
  FLAG_SCHEDULABLE
  ----------------

    This bin iterates itself.

  ---------------------
  FLAG_PREFER_COTHREADS
  ---------------------

    This bin prefers to have cothreads when its an option, over chain-based.

  ----------------
  FLAG_FIXED_CLOCK
  ----------------

    This bin has a fixed clock.



================================================================================
Module Gst::Caps
================================================================================

Capabilities of pads.

Included in: Gst.

Instance methods:

  ---------------
  name -> aString
  ---------------

    Gets the name of the caps.

  ------------------
  type_id -> aFixnum
  ------------------

    Gets the type ID of the caps.

  --------------------------
  == anOtherCaps -> aBoolean
  --------------------------

    Checks if two Gst::Caps objects are refering the same caps.

  ------------------
  fixed? -> aBoolean
  ------------------

    Checks if the GstCaps has fixed properties, ie. 
    it has no ranges or lists.

  ----------------------------------
  has_property?(aString) -> aBoolean
  ----------------------------------

    Checks if the Gst::Caps object has a property 
    with the given name.

  ----------------------------------------
  has_fixed_property?(aString) -> aBoolean
  ----------------------------------------

    Checks if the Gst::Caps object has a fixed property 
    with the given name.

  ------------------------------------------------------
  each_property { |name, value, isFixed| block } -> nil 
  ------------------------------------------------------

    Calls the block for each property of the Gst::Caps, passing references
    of name (String), value (an Object), and fixed state (a Boolean)
    as parameters.



================================================================================
Module Gst::Clock
================================================================================

Abstract class for global clocks.

Included in: Gst.

Class methods:

  ----------------------------
  system_clock -> aClockObject
  ----------------------------

    Gets a handle to the default system clock, as a reference
    to a Gst::Clock object.


Instance methods:

  ------------------
  speed -> anInteger
  ------------------

    Gets the speed of the clock.  
    The returned integer can be either a Fixnum or a Float.

  ---------------
  time -> aFixnum
  ---------------

    Gets the time of the clock (in nanoseconds).

  -------------------
  active? -> aBoolean
  -------------------

    Checks if the clock is active.

  ---------------------------
  == aClockObject -> aBoolean
  ---------------------------

    Checks if two Gst::Clock objects are synchronized on the same time.



================================================================================
Module Gst::Element
================================================================================

Base class for all pipeline elements.

Inherits from: Gst::Object.

Inherited by: Gst::Bin.

Included in: Gst.

Instance methods:

  -----------------------------
  set_state(aFixnum) -> aFixnum
  -----------------------------

    Sets the state of the element. 
    
    This function will try to set the requested state by going through all 
    the intermediary states and calling the class's state change function 
    for each.
    
    Returns an integer code, according to the result of the operation:
    
      - Gst::Element::STATE_FAILURE;
      - Gst::Element::STATE_SUCCESS;
      - Gst::Element::STATE_ASYNC.

  ----------------
  state -> aFixnum
  ----------------

    Gets the state of the element:
    
      - Gst::Element::STATE_NULL;
      - Gst::Element::STATE_READY;
      - Gst::Element::STATE_PAUSED;
      - Gst::Element::STATE_PLAYING.

  ---------------
  stop -> aFixnum
  ---------------

    Calls Gst::Element#set_state with Gst::Element::STATE_NULL.

  ----------------
  ready -> aFixnum
  ----------------

    Calls Gst::Element#set_state with Gst::Element::STATE_READY.

  ----------------
  pause -> aFixnum
  ----------------

    Calls Gst::Element#set_state with Gst::Element::STATE_PAUSED.

  ---------------
  play -> aFixnum
  ---------------

    Calls Gst::Element#set_state with Gst::Element::STATE_PLAYING.

  --------------------
  stopped? -> aBoolean
  --------------------

    Checks if the current state equals Gst::Element::STATE_NULL.

  ------------------
  ready? -> aBoolean
  ------------------

    Checks if the current state equals Gst::Element::STATE_READY.

  -------------------
  paused? -> aBoolean
  -------------------

    Checks if the current state equals Gst::Element::STATE_PAUSED.

  --------------------
  playing? -> aBoolean
  --------------------

    Checks if the current state equals Gst::Element::STATE_PLAYING.

  -------------------------
  wait_state_change -> self
  -------------------------

    Waits and blocks until the element changed its state.

  ---------------------------------------
  set_property(aString, anObject) -> self
  ---------------------------------------

    Sets the value anObject for the property named aString.
    
    If the element uses threadsafe properties, the property will 
    be put on the async queue.

  --------------------------------
  [aString] = anObject -> anObject
  --------------------------------

    Same as Gst::Element#set_property, but returns the provided 
    value instead of a reference to the element.

  ---------------------------------
  get_property(aString) -> anObject
  ---------------------------------

    Returns the value associated with the property named 
    aString, or nil if the property has no value.

  --------------------------------------------------------------------
  each_property { |aStringName, aStringDescr, anObject| block } -> nil
  --------------------------------------------------------------------

    Calls the block for each property of the element, passing
    name (aString), description (aStringDescr) and value (anObject) of the property 
    as parameters.

  -------------------
  sched_yield -> self
  -------------------

    Requests a yield operation for the element. The scheduler 
    will typically give control to another element.

  -----------------------
  sched_interrupt -> self
  -----------------------

    Requests the scheduler of this element to interrupt the 
    execution of this element and scheduler another one.

  ----------------------------
  link(anElement) -> anElement
  ----------------------------

    Links this element (source) to anElement (destination). 
    
    The functions looks for existing pads and request pads that 
    aren't linked yet. If multiple links are possible, only one 
    is established.
    
    Returns the destination element (anElement).

  ---------------------------
  requires_clock? -> aBoolean
  ---------------------------

    Checks if the element requires a clock.

  ---------------------------
  provides_clock? -> aBoolean
  ---------------------------

    Checks if the element provides a clock.

  ---------------------
  clock -> aClockObject
  ---------------------

    Gets the clock of the element, as a Gst::Clock object.
    Returns nil if this element does not provide a clock.

  ---------------
  pads -> anArray
  ---------------

    Gets a list of the pads associated with the element, in an array
    of Gst::Pad objects.

  -----------------------------------
  each_pad { |aGstPad| block } -> nil
  -----------------------------------

    Calls the block for each pad associated with the element, passing a 
    reference to the Gst::Pad as parameter.

  ---------------------
  complex? -> aBoolean 
  ---------------------

    Checks if the Gst::Element::FLAG_COMPLEX flag is set on the object.

  -----------------------
  decoupled? -> aBoolean 
  -----------------------

    Checks if the Gst::Element::FLAG_DECOUPLED flag is set on the object.

  ------------------------------
  thread_suggested? -> aBoolean 
  ------------------------------

    Checks if the Gst::Element::FLAG_THREAD_SUGGESTED flag is set on the 
    object.

  -------------------------------
  has_infinite_loop? -> aBoolean 
  -------------------------------

    Checks if the Gst::Element::FLAG_INFINITE_LOOP flag is set on the object.

  ------------------------------
  has_new_loopfunc? -> aBoolean 
  ------------------------------

    Checks if the Gst::Element::FLAG_NEW_LOOPFUNC flag is set on the object.

  -------------------------
  event_aware? -> aBoolean 
  -------------------------

    Checks if the Gst::Element::FLAG_EVENT_AWARE flag is set on the object.

  ---------------------------------------
  use_threadsafe_properties? -> aBoolean 
  ---------------------------------------

    Checks if the Gst::Element::FLAG_USE_THREADSAFE_PROPERTIES flag 
    is set on the object.

  ----------------------
  indexable? -> aBoolean
  ----------------------

    Checks if the element can be indexed.

  --------------------------
  state=(aFixnum) -> aFixnum
  --------------------------

    Synonym for Gst::Element#set_state.

  ---------------------
  [aString] -> anObject
  ---------------------

    Synonym for Gst::Element#get_property.

  --------------------------
  >>(anElement) -> anElement
  --------------------------

    Synonym for Gst::Element#link.


Constants:

  ----------
  STATE_NULL
  ----------

    The state of the element is reseted.

  -----------
  STATE_READY
  -----------

    The element is ready to start processing data. 
    Some elements might have a non trivial way to initialize themselves.

  ------------
  STATE_PAUSED
  ------------

    Means there really is data flowing temporary stops the data flow.

  -------------
  STATE_PLAYING
  -------------

    Means there really is data flowing through the graph.

  -------------
  STATE_FAILURE
  -------------

    The element could not perform the state change.

  -------------
  STATE_SUCCESS
  -------------

    The element successfully changed its state.

  -----------
  STATE_ASYNC
  -----------

    The element will asynchronously change its state as soon as possible.

  ------------
  FLAG_COMPLEX
  ------------

    This element is complex (for some def.) and generally requires a cothread.

  --------------
  FLAG_DECOUPLED
  --------------

    Input and output pads aren't directly coupled to each other 
    (examples: queues, multi-output async readers, etc...).

  ---------------------
  FLAG_THREAD_SUGGESTED
  ---------------------

    This element should be placed in a thread if at all possible.

  ------------------
  FLAG_INFINITE_LOOP
  ------------------

    This element, for some reason, has a loop function that performs
    an infinite loop without calls to Gst::Element#sched_yield.

  -----------------
  FLAG_NEW_LOOPFUNC
  -----------------

    There is a new lookfunction ready for placement.

  ----------------
  FLAG_EVENT_AWARE
  ----------------

    The element can handle events.

  ------------------------------
  FLAG_USE_THREADSAFE_PROPERTIES
  ------------------------------

    Uses threadsafe property acessors (get/set).



================================================================================
Module Gst::ElementFactory
================================================================================

Creates Gst::Element instances.

Inherits from: Gst::PluginFeature.

Included in: Gst.

Class methods:

  ----------------------------------------------------------------
  make(aFactoryNameString, anElementNameString=nil) -> aGstElement
  ----------------------------------------------------------------

    Creates a new Gst::Element of the type defined by the given element factory.
    
    If element name is ommited (or nil), then the element will receive a guaranteed 
    unique name, consisting of the element factory name and a number. 
    If name is given, it will be given the name supplied.
    
    Example: 
    
      # Creates a 'mad' GStreamer element, named 'foo':
      elem1 = Gst::ElementFactory.make("mad", "foo")
     
      # This line does exactly the same thing:
      elem2 = Gst::ElementFactory.find("mad").create("foo")

  ----------------------------------------------
  find(aFactoryNameString) -> aGstElementFactory
  ----------------------------------------------

    Searches for an element factory of the given name.
    If found, returns a Gst::ElementFactory object.  Otherwise, returns nil.


Instance methods:

  ----------------------------------------------
  create(anElementNameString=nil) -> aGstElement
  ----------------------------------------------

    Creates a new element of the type defined by the element factory.
    
    If element name is ommited (or nil), then the element will receive a guaranteed 
    unique name, consisting of the element factory name and a number. 
    If name is given, it will be given the name supplied.

  ---------------
  rank -> aFixnum
  ---------------

    Gets the rank of the factory:
        
      - Gst::ElementFactory::RANK_MARGINAL;
      - Gst::ElementFactory::RANK_NONE;
      - Gst::ElementFactory::RANK_PRIMARY;
      - Gst::ElementFactory::RANK_SECONDARY.

  --------------------------
  rank_marginal? -> aBoolean
  --------------------------

    Checks if the rank of the factory equals Gst::ElementFactory::RANK_MARGINAL.

  ----------------------
  rank_none? -> aBoolean
  ----------------------

    Checks if the rank of the factory equals Gst::ElementFactory::RANK_NONE.

  -------------------------
  rank_primary? -> aBoolean
  -------------------------

    Checks if the rank of the factory equals Gst::ElementFactory::RANK_PRIMARY.

  ---------------------------
  rank_secondary? -> aBoolean
  ---------------------------

    Checks if the rank of the factory equals Gst::ElementFactory::RANK_SECONDARY.

  ---------------
  to_s -> aString
  ---------------

    Gets a string representing the factory.

  ------------------------
  pad_templates -> anArray
  ------------------------

    Requests all pad templates of factory, in an array 
    of Gst::PadTemplate objects.

  -------------------------------------------------------
  each_pad_template { |aPadTemplateObject| block } -> nil
  -------------------------------------------------------

    Calls the block for each pad template of the factory, passing a
    reference to the Gst::PadTemplate as parameter.

  ----------------
  details -> aHash
  ----------------

    Gets some public information about the factory, 
    mostly for the benefit of editors.
    
    This information is encapsulated in a Hash object, 
    with the following (String) keys:
    
      - longname: long (English) element name.
      - klass: type of element, as hierarchy.
      - license: license under which the element is provided.
      - description: a short description about the element.
      - version: version of the element.
      - author: some information about the author(s).
      - copyright: some copyright details (year, etc..).
    
    Example: 
    
      # Prints all details related to the 'mad' element:
      Gst::ElementFactory.find("mad").details do |k, v| 
          p "#{k}: #{v}"
      end


Constants:

  -------------
  RANK_MARGINAL
  -------------

    The element is only marginally usefull for autoplugging.

  ---------
  RANK_NONE
  ---------

    The plugin may not be used in autoplugging.

  ------------
  RANK_PRIMARY
  ------------

    The plugin is well suited for autoplugging.

  --------------
  RANK_SECONDARY
  --------------

    The plugin is suited for autoplugging but only as a second candidate.



================================================================================
Module Gst::Format
================================================================================

Dynamically register new formats.

Included in: Gst.

Class methods:

  ----------------------------------
  find(aNickString) -> aFormatObject
  ----------------------------------

    Returns a reference to the Gst::Format object registered with the
    given nick, or nil if this query was not registered.

  -------------------------------------
  each { |aFormatObject| block } -> nil
  -------------------------------------

    Calls the block for each registered format, passing a reference
    to the Gst::Format object as parameter.


Instance methods:

  -------------
  id -> aFixnum
  -------------

    Gets the unique id of this format, as an integer value.

  ---------------
  nick -> aString
  ---------------

    Gets the short nick of the format.

  ----------------------
  description -> aString
  ----------------------

    Gets a longer description of the format.

  ----------------------------
  == aFormatObject -> aBoolean
  ----------------------------

    Checks if two Gst::Format objects are registered under the
    same nick.



================================================================================
Module Gst::IndexFactory
================================================================================

Create indexs from a factory.

Inherits from: Gst::PluginFeature.

Included in: Gst.

Instance methods:

  ---------------
  to_s -> aString
  ---------------

    Gets a string representing the factory.



================================================================================
Module Gst::Object
================================================================================

Basis for the GST object hierarchy.

Inherited by: Gst::Element, Gst::Pad, Gst::PadTemplate.

Included in: Gst.

Instance methods:

  ---------------
  name -> aString
  ---------------

    Gets the name of the object.

  -------------------------
  set_name(aString) -> self
  -------------------------

    Sets the name of the object, getting rid of the old name if there was one.

  -------------------------
  name=(aString) -> aString
  -------------------------

    Sets the name of the object, getting rid of the old name if there was one.
    This does exactly the same thing as Gst::Object#set_name but it returns
    the new name instead of a reference to the object.

  ----------------
  flags -> aFixnum
  ----------------

    Gets the entire set of flags for the object.

  --------------------------
  flag?(aFixnum) -> aBoolean
  --------------------------

    Checks if the given flag is set on the object.

  --------------------------
  set_flag(aFixnum) -> self 
  --------------------------

    Sets the given flag.

  ----------------------------
  unset_flag(aFixnum) -> self 
  ----------------------------

    Unsets the given flag.

  ----------------------
  destroyed? -> aBoolean
  ----------------------

    Checks if the Gst::Object::FLAG_DESTROYED flag is set on the object.

  ---------------------
  floating? -> aBoolean
  ---------------------

    Checks if the Gst::Object::FLAG_FLOATING flag is set on the object.


Constants:

  --------------
  FLAG_DESTROYED
  --------------

    The object is flagged for destruction.

  -------------
  FLAG_FLOATING
  -------------

    The object is created but has no parent yet to manage it.



================================================================================
Module Gst::Pad
================================================================================

The link between Gst::Element objects.

Inherits from: Gst::Object.

Included in: Gst.

Instance methods:

  --------------------
  direction -> aFixnum
  --------------------

    Gets the pad's direction.

  ----------------------------
  pad_template -> aPadTemplate
  ----------------------------

    Gets the Gst::PadTemplate object of this pad.

  -----------------------------
  provides_formats? -> aBoolean
  -----------------------------

    Checks if the pad supports formats not handled by
    the default format dispatcher.

  ---------------------------------
  provides_event_masks? -> aBoolean
  ---------------------------------

    Checks if the pad supports event masks not handled by
    the default event masks dispatcher.

  ---------------------------------
  provides_query_types? -> aBoolean
  ---------------------------------

    Checks if the pad supports query types not handled by
    the default query types dispatcher.

  ------------------
  formats -> anArray
  ------------------

    Gets the list of supported formats from the pad, in an array
    of Gst::Format objects.

  ------------------
  event_masks -> nil
  ------------------

    Not yet implemented.

  ----------------------
  query_types -> anArray
  ----------------------

    Gets a list of supported queries that can be performed on the pad,
    in an array of Gst::QueryType objects.

  --------------------------------------------
  each_format { |aFormatObject| block } -> nil
  --------------------------------------------

    Calls the block for each supported format from the pad, passing
    a reference to the Gst::Format object as parameter.

  ----------------------
  each_event_mask -> nil
  ----------------------

    Not yet implemented.

  ---------------------------------------------------
  each_query_type { |aQueryTypeObject| block } -> nil
  ---------------------------------------------------

    Calls the block for each supported query from the pad, passing
    a reference to the Gst::QueryType object as parameter.

  ---------------------
  disabled? -> aBoolean
  ---------------------

    Checks if the Gst::Pad::FLAG_DISABLED flag is set on the object.

  ------------------------
  negotiating? -> aBoolean
  ------------------------

    Checks if the Gst::Pad::FLAG_NEGOTIATING flag is set on the object.


Constants:

  ---------------
  PRESENCE_ALWAYS
  ---------------

    The pad is always available.

  ------------------
  PRESENCE_SOMETIMES
  ------------------

    The pad will become available depending on the media stream.

  ----------------
  PRESENCE_REQUEST
  ----------------

    The pad is only available on request 
    with Gst::Element#request_pad_by_name or 
    or Gst::Element#request_compatible_pad.

  -----------------
  DIRECTION_UNKNOWN
  -----------------

    Direction is unknown.

  -------------
  DIRECTION_SRC
  -------------

    The pad is a source pad.

  --------------
  DIRECTION_SINK
  --------------

    The pad is a sink pad.

  -------------
  FLAG_DISABLED
  -------------

    The pad is disabled.

  ----------------
  FLAG_NEGOTIATING
  ----------------

    The pad is currently negotiating with another pad.



================================================================================
Module Gst::PadTemplate
================================================================================

Describe the media type of a Gst::Pad.

Inherits from: Gst::Object.

Included in: Gst.

Instance methods:

  ---------------
  name -> aString
  ---------------

    Gets the name of the pad template.
    This overrides Gst::Object#get_name.

  -------------------
  presence -> aFixnum
  -------------------

    Gets presence:
    
      - Gst::Pad::PRESENCE_ALWAYS;
      - Gst::Pad::PRESENCE_SOMETIMES;
      - Gst::Pad::PRESENCE_REQUEST.

  --------------------
  direction -> aFixnum
  --------------------

    Gets direction:
    
      - Gst::Pad::DIRECTION_SRC;
      - Gst::Pad::DIRECTION_SINK;
      - Gst::Pad::DIRECTION_UNKNOWN.

  ---------------
  caps -> anArray
  ---------------

    Gets the capabilities of the pad template element, 
    in an array of Gst::Caps object.

  ----------------------------------------
  each_caps { |aCapsObject| block } -> nil
  ----------------------------------------

    Calls the block for each capability of the pad template, 
    passing a reference to the Gst::Caps object as parameter.

  ---------------------
  has_caps? -> aBoolean
  ---------------------

    Checks if the pad template has capabilities.



================================================================================
Module Gst::Pipeline
================================================================================

In almost all cases, you'll want to use a Gst::Pipeline when creating a 
filter graph. The Gst::Pipeline will manage all the scheduling issues, 
including threading, as well as provide simple interfaces to common 
functions, like 'Play'.

Inherits from: Gst::Object <- Gst::Element <- Gst::Bin.

Included in: Gst.

Class methods:

  --------------------------------
  new(aStringName) -> aGstPipeline
  --------------------------------

    Creates a new pipeline with the given name.
    
    Returns nil if the pipeline could not be created.



================================================================================
Module Gst::Plugin
================================================================================

Dynamically loadable Elements

Included in: Gst.

Instance methods:

  ---------------
  name -> aString
  ---------------

    Gets (short) name of the plugin.

  -------------------
  longname -> aString
  -------------------

    Gets long name (descriptive) of the plugin.

  -------------------
  filename -> aString
  -------------------

    Gets the file name where the plugin cames from.

  -------------------
  loaded? -> aBoolean
  -------------------

    Checks if the plugin is loaded into memory.

  -------------------
  features -> anArray
  -------------------

    Get a list of all the features that this plugin provides, in an array
    of Gst::PluginFeature objects.

  -----------------------------------------------
  each_feature { |aPluginFeature| block } -> nil 
  -----------------------------------------------

    Calls the block for each feature this plugin provides, passing
    a reference to the Gst::PluginFeature object as parameter.

  ----------------------------
  == anOtherPlugin -> aBoolean
  ----------------------------

    Checks if two Gst::Plugin objects are refered by the same file.



================================================================================
Module Gst::PluginFeature
================================================================================

This is a base class for anything that can be added to a Gst::Plugin.

Inherited by: Gst::AutoplugFactory, Gst::ElementFactory, Gst::IndexFactory, Gst::SchedulerFactory, Gst::TypeFactory.

Included in: Gst.

Instance methods:

  ---------------
  name -> aString
  ---------------

    Gets the name of the feature.



================================================================================
Module Gst::QueryType
================================================================================

Dynamically register new query types.

Included in: Gst.

Class methods:

  -------------------------------------
  find(aNickString) -> aQueryTypeObject
  -------------------------------------

    Returns a reference to the Gst::QueryType object registered with the 
    given nick, or nil if this query was not registered.

  ----------------------------------------
  each { |aQueryTypeObject| block } -> nil
  ----------------------------------------

    Calls the block for each registered querytype, passing a reference
    to the Gst::QueryType object as parameter.


Instance methods:

  -------------
  id -> aFixnum
  -------------

    Gets the unique id of this querytype, as an integer value.

  ---------------
  nick -> aString
  ---------------

    Gets the short nick of the querytype.

  ----------------------
  description -> aString
  ----------------------

    Gets a longer description of the querytype.

  -------------------------------
  == aQueryTypeObject -> aBoolean
  -------------------------------

    Checks if two Gst::QueryType objects are registered under the
    same nick.



================================================================================
Module Gst::Registry
================================================================================

Abstract class for managing plugins.

Included in: Gst.

Class methods:

  ------------------
  plugins -> anArray
  ------------------

    Get a list of all plugins in the pool, in an array of Gst::Plugin objects.

  --------------------------------------
  each_plugin { |aPlugin| block } -> nil
  --------------------------------------

    Calls the block for each plugin in the pool, passing a reference to
    the Gst::Plugin as parameter.

  --------------------------------------------
  find_plugin(aNameString) -> aGstPluginObject
  --------------------------------------------

    Find the plugin with the given name in the registry. 
    If founds, returns a reference to the Gst::Plugin object, otherwise
    returns nil.

  ---------------------
  registries -> anArray
  ---------------------

    Gets a list of all registries in the pool, in an Array
    of Gst::Registry objects.

  ---------------------------------------
  each { |aRegistryObject| block } -> nil
  ---------------------------------------

    Calls the block for each registries in the pool, passing a reference to
    the Gst::Registry as parameter.


Instance methods:

  ---------------
  name -> aString
  ---------------

    Gets the name of the registry.

  ------------------
  details -> aString
  ------------------

    Gets some details about the registry.  May be nil.

  -------------------
  loaded? -> aBoolean
  -------------------

    Checks if the registry is currently loaded.

  ----------------
  paths -> anArray
  ----------------

    Gets a list of paths of the registry, in an Array of String objects.

  ------------------------------------
  each_path { |aString| block } -> nil
  ------------------------------------

    Calls the block for each path of the registry, passing a reference to
    the path String as parameter.



================================================================================
Module Gst::SchedulerFactory
================================================================================

Create schedulers from a factory.

Inherits from: Gst::PluginFeature.

Included in: Gst.

Instance methods:

  ---------------
  to_s -> aString
  ---------------

    Gets a string representing the factory.



================================================================================
Module Gst::Type
================================================================================

Identifies the data.

Included in: Gst.

Class methods:

  ----------------
  types -> anArray
  ----------------

    Returns a list of all registered types, in an array 
    of Gst::Type objects.

  -----------------------------------
  each { |aTypeObject| block } -> nil
  -----------------------------------

    Calls the block for each registred types, passing a reference to
    the Gst::Type as parameter.

  ----------------------------------
  find_by_id(aFixnum) -> aTypeObject
  ----------------------------------

    Searches for a registered type of the given ID.  
    If found, returns a Gst::Type object. Otherwise, returns nil.

  ------------------------------------
  find_by_mime(aString) -> aTypeObject
  ------------------------------------

    Searches for a registered type of the given MIME type.  
    If found, returns a Gst::Type object.  Otherwise, returns nil.


Instance methods:

  -------------
  id -> aFixnum
  -------------

    Gets the ID number of the type.

  ---------------
  mime -> aString
  ---------------

    Gets the MIME type of the type.

  ---------------
  exts -> aString
  ---------------

    Gets files extentions handled by the type, if there
    are any.  This method may otherwise return nil.

  --------------------------
  == aTypeObject -> aBoolean
  --------------------------

    Checks if two Gst::Type objects are refered under the same ID number.



================================================================================
Module Gst::TypeFactory
================================================================================

Add types to plugins.

Inherits from: Gst::PluginFeature.

Included in: Gst.

Class methods:

  ----------------------------------------------
  find(aFactoryNameString) -> aTypeFactoryObject
  ----------------------------------------------

    Searches for a type factory of the given name.
    If founds, returns a Gst::TypeFactory object.  Otherwise, returns nil.


Instance methods:

  ---------------
  mime -> aString
  ---------------

    Gets the mime type handled by the factory.

  ---------------
  exts -> aString
  ---------------

    Gets the files extentions handled by the factory.

  ---------------
  to_s -> aString
  ---------------

    Gets a string representing the factory.


--
This file has been generated by extdoc.rb 0.1.3, Mon Jul 07 21:45:31 CEST 2003.
Extdoc.rb is free software, written by Laurent Sansonetti, released under the GNU General Public License.
