Caps

Object Hierarchy:

Description:

public class Caps

Caps (capabilities) are lighweight refcounted objects describing media types. They are composed of an array of Structure. Caps are exposed on PadTemplate to describe all possible types a given pad can handle. They are also stored in the Registry along with a description of the Element. Caps are exposed on the element pads using the get_caps pad function. This function describes the possible types that the pad can handle or produce at runtime. Caps are also attached to buffers to describe to content of the data pointed to by the buffer with set_caps. Caps attached to a Buffer allow for format negotiation upstream and downstream. A Caps can be constructed with the following code fragment:

Creating caps:


GstCaps *caps;
caps = gst_caps_new_simple ("video/x-raw-yuv",
"format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
"framerate", GST_TYPE_FRACTION, 25, 1,
"pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1,
"width", G_TYPE_INT, 320,
"height", G_TYPE_INT, 240,
NULL);

A Caps is fixed when it has no properties with ranges or lists. Use is_fixed to test for fixed caps. Only fixed caps can be set on a Pad or Buffer. Various methods exist to work with the media types such as subtracting or intersecting. Last reviewed on 2007-02-13 (0.10.10)

Namespace: Gst

Package: gstreamer-0.10

Content:

Static methods:

public static Caps from_string (string str)
Converts caps from a string representation.
public static Caps load_thyself (void* parent)
Creates a Caps from its XML serialization.
public static void replace (ref Caps? oldobj, Caps? newobj)
Replaces *caps with newcaps. Unrefs the Caps in the location pointed to by caps, if applicable, then modifies caps to point to This function does not take any locks so you might want to lock the object owning caps pointer.

Creation methods:

public Caps.any ()
Creates a new Caps that indicates that it is compatible with any media format.
public Caps.empty ()
Creates a new Caps that is empty. That is, the returned Caps contains no media formats. Caller is responsible for unreffing the returned caps.
public Caps.full (Structure struct1, ...)
Creates a new Caps and adds all the structures listed as arguments. The list must be NULL-terminated. The structures are not copied; the returned Caps owns the structures.
public Caps.full_valist (Structure structure, void* var_args)
Creates a new Caps and adds all the structures listed as arguments. The list must be NULL-terminated. The structures are not copied; the returned Caps owns the structures.
public Caps.simple (string media_type, string fieldname, ...)
Creates a new Caps that contains one Structure. The structure is defined by the arguments, which have the same format as Structure. Caller is responsible for unreffing the returned caps.

Methods:

public void append (owned Caps caps2)
Appends the structures contained in caps2 to caps1. The structures in freed. If either caps is ANY, the resulting caps will be ANY.
public void append_structure (owned Structure structure)
Appends structure to caps. The structure is not copied; caps becomes the owner of structure.
public bool can_intersect (Caps caps2)
Tries intersecting caps1 and caps2 and reports whether the result would not be empty
public Caps copy ()
Creates a new Caps as a copy of the old caps. The new caps will have a refcount of 1, owned by the caller. The structures are copied as well. Note that this function is the semantic equivalent of a ref followed by a make_writable. If you only want to hold on to a reference to the data, you should use ref. When you are finished with the caps, call unref on it.
public Caps copy_nth (uint nth)
Creates a new Caps and appends a copy of the nth structure contained in caps.
public bool do_simplify ()
Modifies the given caps inplace into a representation that represents the same set of formats, but in a simpler form. Component structures that are identical are merged. Component structures that have values that can be merged are also merged.
public uint get_size ()
Gets the number of structures contained in caps.
public unowned Structure get_structure (uint index)
Finds the structure in caps that has the index index, and returns it. non-const GstStructure *. This is for programming convenience -- the caller should be aware that structures inside a constant Caps should not be modified. However, if you know the caps are writable, either because you have just copied them or made them writable with make_writable, you may modify the structure returned in the usual way, e.g. with functions like set. You do not need to free or unref the structure returned, it belongs to the Caps. to index
public Caps intersect (Caps caps2)
Creates a new Caps that contains all the formats that are common to both caps1 and caps2. Defaults to ZIG_ZAG mode.
public weak Caps intersect_full (Caps caps2, CapsIntersectMode mode)
Creates a new Caps that contains all the formats that are common to both caps1 and caps2, the order is defined by the CapsIntersectMode used.
public bool is_always_compatible (Caps caps2)
A given Caps structure is always compatible with another if every media format that is in the first is also contained in the second. That is, caps1 is a subset of caps2 .
public bool is_any ()
Determines if caps represents any media format.
public bool is_empty ()
Determines if caps represents no media formats.
public bool is_equal (Caps caps2)
Checks if the given caps represent the same set of caps.
public bool is_equal_fixed (Caps caps2)
Tests if two Caps are equal. This function only works on fixed Caps.
public bool is_fixed ()
Fixed Caps describe exactly one format, that is, they have exactly one structure, and each field in the structure describes a fixed type. Examples of non-fixed types are GST_TYPE_INT_RANGE and GST_TYPE_LIST.
public bool is_simple ()
public bool is_subset (Caps superset)
Checks if all caps represented by subset are also represented by superset.
public bool is_subset_structure (Structure structure)
public void make_writable ()
Returns a writable copy of caps. If there is only one reference count on caps, the caller must be the owner, and so this function will return the caps object unchanged. If on the other hand there is more than one reference on the object, a new caps object will be returned. The caller's reference on caps will be removed, and instead the caller will own a reference to the returned object. In short, this function unrefs the caps in the argument and refs the caps that it returns. Don't access the argument after calling this function. See
public void merge (owned Caps caps2)
Appends the structures contained in caps2 to caps1 if they are not yet expressed by caps1. The structures in caps2 are not copied -- they are transferred to caps1, and then caps2 is freed. If either caps is ANY, the resulting caps will be ANY.
public void merge_structure (owned Structure structure)
Appends structure to caps if its not already expressed by caps. The structure is not copied; caps becomes the owner of structure.
public Caps normalize ()
Creates a new Caps that represents the same set of formats as
public weak Caps ref ()
Add a reference to a Caps object. From this point on, until the caller calls unref or make_writable, it is guaranteed that the caps object will not change. This means its structures won't change, etc. To use a Caps object, you must always have a refcount on it -- either the one made implicitly by e.g. Caps.simple, or via taking one explicitly with this function.
public void remove_structure (uint idx)
removes the stucture with the given index from the list of structures contained in caps.
public void* save_thyself (void* parent)
Serializes a Caps to XML and adds it as a child node of parent.
public void set_simple (string field, ...)
Sets fields in a Caps. The arguments must be passed in the same manner as set, and be NULL-terminated.
public void set_simple_valist (string field, void* varargs)
Sets fields in a Caps. The arguments must be passed in the same manner as set, and be NULL-terminated.
public void set_value (string field, Value value)
Sets the given field on all structures of caps to the given value . This is a convenience function for calling set_value on all structures of caps.
public unowned Structure steal_structure (uint index)
Retrieves the stucture with the given index from the list of structures contained in caps. The caller becomes the owner of the returned structure. to index.
public Caps subtract (Caps subtrahend)
Subtracts the subtrahend from the minuend.
public string to_string ()
Converts caps to a string representation. This string representation can be converted back to a Caps by from_string. For debugging purposes its easier to do something like this:
public void truncate ()
Destructively discard all but the first structure from caps. Useful when fixating. caps must be writable.
public Caps union (Caps caps2)
Creates a new Caps that contains all the formats that are in either caps1 and caps2.
public void unref ()
Unref a Caps and and free all its structures and the structures' values when the refcount reaches 0.

Fields:

public CapsFlags flags