\n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstBin.html\n *
\n * Bin is an element that can contain other {@link Element}s, allowing them to\n * be managed as a group.\n *
\n * Pads from the child elements can be ghosted to the bin, see {@link GhostPad}.\n * This makes the bin look like any other elements and enables creation of\n * higher-level abstraction elements.\n *
\n * A new {@link Bin} is created with {@link Bin#Bin(String)}. Use a\n * {@link Pipeline} instead if you want to create a toplevel bin because a\n * normal bin doesn't have a bus or handle clock distribution of its own.\n *
\n * After the bin has been created you will typically add elements to it with\n * {@link Bin#add(Element)}. Elements can be removed with\n * {@link Bin#remove(Element)}\n *
\n * An element can be retrieved from a bin with\n * {@link Bin#getElementByName(String)}.\n *
\n * A list of elements contained in a bin can be retrieved with\n * {@link Bin#getElements}\n *\n * The {@link ELEMENT_ADDED} signal is fired whenever a new element is added to\n * the bin. Likewise the {@link ELEMENT_REMOVED} signal is fired whenever an\n * element is removed from the bin.\n *\n */\npublic class Bin extends Element {\n\n public static final String GST_NAME = \"bin\";\n public static final String GTYPE_NAME = \"GstBin\";\n\n protected Bin(Initializer init) {\n super(init);\n }\n\n Bin(Handle handle, boolean needRef) {\n super(handle, needRef);\n }\n \n /**\n * Creates a new Bin with a unique name.\n */\n public Bin() {\n this(Natives.initializer(GSTBIN_API.ptr_gst_bin_new(null), false, true));\n }\n\n /**\n * Creates a new Bin with the given name.\n *\n * @param name The Name to assign to the new Bin\n */\n public Bin(String name) {\n this(Natives.initializer(GSTBIN_API.ptr_gst_bin_new(name), false, true));\n }\n\n /**\n * Adds an Element to this Bin.\n *
\n * Sets the element's parent, and thus takes ownership of the element. An\n * element can only be added to one bin.\n *
\n * If the element's pads are linked to other pads, the pads will be unlinked\n * before the element is added to the bin.\n *\n * @param element The {@link Element} to add to this Bin.\n * @return true if the element was successfully added, false if the Bin will\n * not accept the element.\n */\n public boolean add(Element element) {\n return GSTBIN_API.gst_bin_add(this, element);\n }\n\n /**\n * Adds an array of Element objects to this Bin\n *\n * @param elements The array of {@link Element} to add to this Bin\n * @see Bin#add(Element)\n */\n public void addMany(Element... elements) {\n GSTBIN_API.gst_bin_add_many(this, elements);\n }\n\n /**\n * Removes a Element from this Bin\n *
\n * Removes the element from the bin, unparenting it as well.\n *\n * If the element's pads are linked to other pads, the pads will be unlinked\n * before the element is removed from the bin.\n *\n * @param element The {@link Element} to remove\n * @return true if the element was successfully removed\n */\n public boolean remove(Element element) {\n return GSTBIN_API.gst_bin_remove(this, element);\n }\n\n /**\n * Removes an array of {@link Element} objects from this Bin\n *\n * @param elements The list {@link Element} to remove\n */\n public void removeMany(Element... elements) {\n GSTBIN_API.gst_bin_remove_many(this, elements);\n }\n\n private List \n * The function is only active if gstreamer is configured with\n * \"--gst-enable-gst-debug\" and the environment variable\n * GST_DEBUG_DUMP_DOT_DIR is set to a basepath (e.g. /tmp).\n *\n * @param details to show in the graph\n * @param fileName output base filename (e.g. \"myplayer\")\n */\n public void debugToDotFile(EnumSet \n * The function is only active if gstreamer is configured with\n * \"--gst-enable-gst-debug\" and the environment variable\n * GST_DEBUG_DUMP_DOT_DIR is set to a basepath (e.g. /tmp).\n * \n * Unlike {@link #debugToDotFile(java.util.EnumSet, java.lang.String)} this\n * method adds the current timestamp to the filename, so that it can be\n * used to take multiple snapshots.\n * \n * @param details to show in the graph\n * @param fileName output base filename (e.g. \"myplayer\")\n */\n public void debugToDotFileWithTS(EnumSet \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstBuffer.html\n */\npublic class Buffer extends MiniObject {\n\n public static final String GTYPE_NAME = \"GstBuffer\";\n\n private final MapInfoStruct mapInfo;\n private final BufferStruct struct;\n\n /**\n * Creates a newly allocated buffer without any data.\n */\n public Buffer() {\n this(Natives.initializer(GSTBUFFER_API.ptr_gst_buffer_new()));\n }\n\n /**\n * Creates a newly allocated buffer with data of the given size. The buffer\n * memory is not cleared. If the requested amount of memory cannot be\n * allocated, an exception will be thrown.\n * \n * Note that when size == 0, the buffer data pointer will be NULL.\n *\n * @param size\n */\n public Buffer(int size) {\n this(Natives.initializer(allocBuffer(size)));\n }\n\n Buffer(Initializer init) {\n super(init);\n mapInfo = new MapInfoStruct();\n struct = new BufferStruct(getRawPointer());\n }\n\n private static Pointer allocBuffer(int size) {\n Pointer ptr = GSTBUFFER_API.ptr_gst_buffer_new_allocate(null, size, null);\n if (ptr == null) {\n throw new OutOfMemoryError(\"Could not allocate Buffer of size \" + size);\n }\n return ptr;\n }\n\n /**\n * Gets a {@link java.nio.ByteBuffer} that can access the native memory\n * associated with this Buffer, with the option of ensuring the memory is\n * writable.\n * \n * When requesting a writable buffer, if the buffer is writable but the\n * underlying memory isn't, a writable copy will automatically be created\n * and returned. The readonly copy of the buffer memory will then also be\n * replaced with this writable copy.\n * \n * The Buffer should be unmapped with {@link #unmap()} after usage.\n *\n * @param writable\n * @return A {@link java.nio.ByteBuffer} that can access this Buffer's data.\n */\n public ByteBuffer map(boolean writable) {\n final boolean ok = GSTBUFFER_API.gst_buffer_map(this, mapInfo,\n writable ? GstBufferAPI.GST_MAP_WRITE : GstBufferAPI.GST_MAP_READ);\n if (ok && mapInfo.data != null) {\n return mapInfo.data.getByteBuffer(0, mapInfo.size.intValue());\n }\n return null;\n }\n\n /**\n * Release the memory previously mapped with {@link #map(boolean)}\n */\n public void unmap() {\n GSTBUFFER_API.gst_buffer_unmap(this, mapInfo);\n }\n\n /**\n * Get the amount of memory blocks that this buffer has. This amount is never\n * larger than what {@code gst_buffer_get_max_memory()} returns.\n *\n * @return the number of memory blocks this buffer is made of.\n */\n public int getMemoryCount() {\n return GSTBUFFER_API.gst_buffer_n_memory(this);\n }\n\n /**\n * Gets the timestamps of this buffer. The buffer DTS refers to the\n * timestamp when the buffer should be decoded and is usually monotonically\n * increasing.\n *\n * @return a long representing the timestamp or {@link ClockTime#NONE}\n * when the timestamp is not known or relevant.\n */\n public long getDecodeTimestamp() {\n return (long) this.struct.readField(\"dts\");\n }\n\n /**\n * Set the decode timestamp of the Buffer\n *\n * @param val a long representing the timestamp or\n * {@link ClockTime#NONE} when the timestamp is not known or relevant.\n */\n public void setDecodeTimestamp(long val) {\n this.struct.writeField(\"dts\", val);\n }\n\n /**\n * Gets the timestamps of this buffer. The buffer PTS refers to the\n * timestamp when the buffer content should be presented to the user and is\n * not always monotonically increasing.\n *\n * @return a long representing the timestamp or {@link ClockTime#NONE}\n * when the timestamp is not known or relevant.\n */\n public long getPresentationTimestamp() {\n return (long) this.struct.readField(\"pts\");\n }\n\n /**\n * Set the presentation timestamp of the Buffer\n *\n * @param val a long representing the timestamp or\n * {@link ClockTime#NONE} when the timestamp is not known or relevant.\n */\n public void setPresentationTimestamp(long val) {\n this.struct.writeField(\"pts\", val);\n }\n\n /**\n * Gets the duration of this buffer.\n *\n * @return a ClockTime representing the timestamp or {@link ClockTime#NONE}\n * when the timestamp is not known or relevant.\n */\n public long getDuration() {\n return (long) this.struct.readField(\"duration\");\n }\n\n /**\n * Set the duration of this buffer.\n *\n * @param val a long representing the duration or\n * {@link ClockTime#NONE} when the timestamp is not known or relevant.\n */\n public void setDuration(long val) {\n this.struct.writeField(\"duration\", val);\n }\n\n /**\n * Get the offset (media-specific) of this buffer\n *\n * @return a media specific offset for the buffer data. For video frames,\n * this is the frame number of this buffer. For audio samples, this is the\n * offset of the first sample in this buffer. For file data or compressed\n * data this is the byte offset of the first byte in this buffer.\n */\n public long getOffset() {\n return (Long) this.struct.readField(\"offset\");\n }\n\n /**\n * Set the offset (media-specific) of this buffer\n *\n * @param val a media specific offset for the buffer data. For video frames,\n * this is the frame number of this buffer. For audio samples, this is the\n * offset of the first sample in this buffer. For file data or compressed\n * data this is the byte offset of the first byte in this buffer.\n */\n public void setOffset(long val) {\n this.struct.writeField(\"offset\", val);\n }\n\n /**\n * Get the offset (media-specific) of this buffer\n *\n * @return a media specific offset for the buffer data. For video frames,\n * this is the frame number of this buffer. For audio samples, this is the\n * offset of the first sample in this buffer. For file data or compressed\n * data this is the byte offset of the first byte in this buffer.\n */\n public long getOffsetEnd() {\n return (Long) this.struct.readField(\"offset_end\");\n }\n\n /**\n * Set the offset (media-specific) of this buffer\n *\n * @param val a media specific offset for the buffer data. For video frames,\n * this is the frame number of this buffer. For audio samples, this is the\n * offset of the first sample in this buffer. For file data or compressed\n * data this is the byte offset of the first byte in this buffer.\n */\n public void setOffsetEnd(long val) {\n this.struct.writeField(\"offset_end\", val);\n }\n\n /**\n * Get the GstBufferFlags describing this buffer.\n * \n * Since GStreamer 1.10\n *\n * @return an EnumSet of {@link BufferFlags}\n */\n @Gst.Since(minor = 10)\n public EnumSet \n * Since GStreamer 1.14\n *\n * @param \n * Since GStreamer 1.14\n *\n * @param \n * Since GStreamer 1.10\n *\n * @param flags an EnumSet of {@link BufferFlags} to be set on the buffer.\n * @return true if flags were successfully set on this buffer\n */\n @Gst.Since(minor = 10)\n public boolean setFlags(EnumSet \n * Since GStreamer 1.10\n *\n * @param flags an EnumSet of {@link BufferFlags} to be cleared on the buffer.\n * @return true if flags were successfully cleared on this buffer\n *\n */\n @Gst.Since(minor = 10)\n public boolean unsetFlags(EnumSet \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstBufferPool.html\n */\npublic class BufferPool extends GstObject {\n\n public static final String GTYPE_NAME = \"GstBufferPool\";\n\n /**\n * Creates a new instance of BufferPool\n */\n public BufferPool() {\n this(Natives.initializer(GstBufferPoolAPI.GSTBUFFERPOOL_API.ptr_gst_buffer_pool_new()));\n }\n \n /**\n * This constructor is for internal use only.\n * @param init initialization data.\n */\n BufferPool(final Initializer init) {\n super(init);\n }\n\n /**\n * Configure the BufferPool with the given parameters.\n * \n * @param caps the {@link Caps} for the buffers\n * @param size the size of each buffer, not including prefix and padding\n * @param min_buffers the minimum amount of buffers to allocate\n * @param max_buffers the maximum amount of buffers to allocate or 0 for unlimited\n */\n public void setParams(Caps caps, int size, int min_buffers, int max_buffers) {\n \tStructure config = GstBufferPoolAPI.GSTBUFFERPOOL_API.gst_buffer_pool_get_config(this);\n \tGstBufferPoolAPI.GSTBUFFERPOOL_API.gst_buffer_pool_config_set_params(config, caps, size, min_buffers, max_buffers);\n }\n\n /**\n * Query the {@link Caps} configured on the BufferPool.\n * \n * @return Caps configured on the BufferPool\n */\n public Caps getCaps() {\n \tStructure config = GstBufferPoolAPI.GSTBUFFERPOOL_API.gst_buffer_pool_get_config(this);\n \tPointer[] ptr = new Pointer[1];\n \tGstBufferPoolAPI.GSTBUFFERPOOL_API.gst_buffer_pool_config_get_params(config, ptr, null, null, null);\n \treturn new Caps(Natives.initializer(ptr[0], false, true));\n }\n\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/Bus.java",
"content": "/* \n * Copyright (c) 2025 Neil C Smith\n * Copyright (C) 2014 Tom Greenwood \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/documentation/gstreamer/gstbus.html\n * \n * Since the application typically only wants to deal with delivery of these\n * messages from one thread, the Bus will marshal the messages between different\n * threads. This is important since the actual streaming of media is done in\n * another thread than the application.\n * \n * It is also possible to get messages from the bus without any thread\n * marshalling with the {@link #setSyncHandler} method. This makes it possible\n * to react to a message in the same thread that posted the message on the bus.\n * This should only be used if the application is able to deal with messages\n * from different threads.\n * \n * Every {@link Pipeline} has one bus.\n * \n * Note that a Pipeline will set its bus into flushing state when changing from\n * READY to NULL state.\n */\npublic class Bus extends GstObject {\n\n public static final String GTYPE_NAME = \"GstBus\";\n\n private static final Logger LOG = Logger.getLogger(Bus.class.getName());\n private static final SyncCallback SYNC_CALLBACK = new SyncCallback();\n\n private volatile BusSyncHandler syncHandler = null;\n\n private final Object lock = new Object();\n private final List \n * Only one handler may be attached to the bus at any one time. An attached\n * sync handler forces creation of {@link Message} objects for all messages\n * on the bus, so the handler should be removed if no longer required.\n * \n * A single native sync handler is used at all times, with synchronous and\n * asynchronous dispatch handled on the Java side, so the bindings do not\n * inherit issues in clearing or replacing the sync handler with versions of\n * GStreamer prior to 1.16.3.\n *\n * @param handler bus sync handler, or null to remove\n */\n public void setSyncHandler(BusSyncHandler handler) {\n syncHandler = handler;\n }\n\n /**\n * Clear the synchronous handler.\n * \n * This is a convenience method equivalent to {@code setSyncHandler(null)}\n */\n public void clearSyncHandler() {\n setSyncHandler(null);\n }\n\n /**\n * Get the current synchronous handler.\n *\n * @return current sync handler, or null\n */\n public BusSyncHandler getSyncHandler() {\n return syncHandler;\n }\n\n /**\n * Connects to a signal.\n *\n * The signal name is deduced from the listenerClass name.\n *\n * @param listenerClass the class of the listener.\n * @param listener the listener to associate with the {@code callback}\n * @param callback The callback to call when the signal is emitted.\n */\n private \n * This differs to {@link GObject#connect} in that it hooks up Bus signals\n * to the sync callback, not the generic GObject signal mechanism.\n *\n * @param \n * We do this here from a sync callback, because the default gstbus dispatch\n * uses the default main context to signal that there are messages waiting\n * on the bus. Since that is used by the GTK L&F under swing, we never get\n * those notifications, and the messages just queue up.\n *\n */\n private void dispatchMessage(GstBusPtr busPtr, GstMessagePtr msgPtr) {\n messageProxies.forEach(p -> {\n try {\n p.busMessage(busPtr, msgPtr);\n } catch (Throwable t) {\n LOG.log(Level.SEVERE, \"Exception thrown by bus message handler\", t);\n }\n });\n GSTMINIOBJECT_API.gst_mini_object_unref(msgPtr);\n }\n\n @Override\n public void dispose() {\n removeWatch();\n super.dispose();\n }\n\n /**\n * Adds the bus signal watch. This will reference the bus until the signal\n * watch is removed and so will stop the Bus being GC'd and disposed.\n */\n private void addWatch() {\n synchronized (lock) {\n if (!watchAdded) {\n LOG.fine(\"Add watch\");\n GSTBUS_API.gst_bus_add_signal_watch(this);\n watchAdded = true;\n }\n }\n }\n\n /**\n * Removes the bus signal watch (which will remove the bus reference held by\n * the signal watch).\n */\n private void removeWatch() {\n synchronized (lock) {\n if (watchAdded) {\n LOG.fine(\"Remove watch\");\n GSTBUS_API.gst_bus_remove_signal_watch(this);\n watchAdded = false;\n }\n }\n }\n\n /**\n * Signal emitted when end-of-stream is reached in a pipeline.\n *\n * The application will only receive this message in the PLAYING state and\n * every time it sets a pipeline to PLAYING that is in the EOS state. The\n * application can perform a flushing seek in the pipeline, which will undo\n * the EOS state again.\n *\n * @see #connect(EOS)\n * @see #disconnect(EOS)\n */\n public static interface EOS {\n\n /**\n * Called when a {@link Pipeline} element posts a end-of-stream message.\n *\n * @param source the element which posted the message.\n */\n public void endOfStream(GstObject source);\n }\n\n /**\n * Signal emitted when an error occurs.\n * \n * When the application receives an error message it should stop playback of\n * the pipeline and not assume that more data will be played.\n *\n * @see #connect(ERROR)\n * @see #disconnect(ERROR)\n */\n public static interface ERROR {\n\n /**\n * Called when a {@link Pipeline} element posts an error message.\n *\n * @param source the element which posted the message.\n * @param code a numeric code representing the error.\n * @param message a string representation of the error.\n */\n public void errorMessage(GstObject source, int code, String message);\n }\n\n /**\n * Signal emitted when a warning message is delivered.\n *\n * @see #connect(WARNING)\n * @see #disconnect(WARNING)\n */\n public static interface WARNING {\n\n /**\n * Called when a {@link Pipeline} element posts an warning message.\n *\n * @param source the element which posted the message.\n * @param code a numeric code representing the warning.\n * @param message a string representation of the warning.\n */\n public void warningMessage(GstObject source, int code, String message);\n }\n\n /**\n * Signal emitted when an informational message is delivered.\n *\n * @see #connect(INFO)\n * @see #disconnect(INFO)\n */\n public static interface INFO {\n\n /**\n * Called when a {@link Pipeline} element posts an informational\n * message.\n *\n * @param source the element which posted the message.\n * @param code a numeric code representing the informational message.\n * @param message a string representation of the informational message.\n */\n public void infoMessage(GstObject source, int code, String message);\n }\n\n /**\n * Signal emitted when a new tag is identified on the stream.\n *\n * @see #connect(TAG)\n * @see #disconnect(TAG)\n */\n public static interface TAG {\n\n /**\n * Called when a {@link Pipeline} element finds media meta-data.\n *\n * @param source the element which posted the message.\n * @param tagList a list of media meta-data.\n */\n public void tagsFound(GstObject source, TagList tagList);\n }\n\n /**\n * Signal emitted when a state change happens.\n *\n * @see #connect(STATE_CHANGED)\n * @see #disconnect(STATE_CHANGED)\n */\n public static interface STATE_CHANGED {\n\n /**\n * Called when a {@link Pipeline} element executes a {@link State}\n * change.\n *\n * @param source the element which posted the message.\n * @param old the old state that the element is changing from.\n * @param current the new (current) state the element is changing to.\n * @param pending the pending (target) state.\n */\n public void stateChanged(GstObject source, State old, State current, State pending);\n }\n\n /**\n * Signal emitted when the pipeline is buffering data.\n *\n * @see #connect(BUFFERING)\n * @see #disconnect(BUFFERING)\n */\n public static interface BUFFERING {\n\n /**\n * Called when a {@link Pipeline} element needs to buffer data before it\n * can continue processing.\n * \n * {@code percent} is a value between 0 and 100. A value of 100 means\n * that the buffering completed.\n * \n * When {@code percent} is less than 100 the application should PAUSE a\n * PLAYING pipeline. When {@code percent} is 100, the application can\n * set the pipeline (back) to PLAYING.\n * \n * The application must be prepared to receive BUFFERING messages in the\n * PREROLLING state and may only set the pipeline to PLAYING after\n * receiving a message with {@code percent} set to 100, which can happen\n * after the pipeline completed prerolling.\n *\n * @param source the element which posted the message.\n * @param percent the percentage of buffering that has completed.\n */\n public void bufferingData(GstObject source, int percent);\n }\n\n /**\n * Signal sent when a new duration message is posted by an element that know\n * the duration of a stream in a specific format.\n * \n * This message is received by bins and is used to calculate the total\n * duration of a pipeline.\n * \n * Elements may post a duration message with a duration of\n * {@link ClockTime#NONE} to indicate that the duration has changed and the\n * cached duration should be discarded. The new duration can then be\n * retrieved via a query. The application can get the new duration with a\n * duration query.\n *\n * @see #connect(DURATION)\n * @see #disconnect(DURATION)\n */\n public static interface DURATION_CHANGED {\n\n /**\n * Called when a new duration message is posted on the Bus.\n *\n * @param source the element which posted the message.\n */\n public void durationChanged(GstObject source);\n }\n\n /**\n * This message is posted by elements that start playback of a segment as a\n * result of a segment seek.\n * \n * This message is not received by the application but is used for\n * maintenance reasons in container elements.\n */\n public static interface SEGMENT_START {\n\n public void segmentStart(GstObject source, Format format, long position);\n }\n\n /**\n * Signal emitted when the pipeline has completed playback of a segment.\n * \n * This message is posted by elements that finish playback of a segment as a\n * result of a segment seek. This message is received by the application\n * after all elements that posted a {@link SEGMENT_START} have posted\n * segment-done.\n *\n * @see #connect(SEGMENT_DONE)\n * @see #disconnect(SEGMENT_DONE)\n */\n public static interface SEGMENT_DONE {\n\n /**\n * Called when a segment-done message has been posted.\n *\n * @param source the element which posted the message.\n * @param format the format of the position being done.\n * @param position the position of the segment being done.\n */\n public void segmentDone(GstObject source, Format format, long position);\n }\n\n /**\n * Signal emitted by elements when they complete an ASYNC state change.\n * \n * Applications will only receive this message from the top level pipeline.\n * \n * The signal handler will be called asynchronously from the thread that\n * posted the message on the Bus.\n *\n * @see #connect(MESSAGE)\n * @see #disconnect(MESSAGE)\n */\n public static interface MESSAGE {\n\n /**\n * Called when a {@link Element} posts a {@link Message} on the Bus.\n *\n * @param bus the Bus the message was posted on.\n * @param message the message that was posted.\n */\n public void busMessage(Bus bus, Message message);\n }\n\n private static class MessageProxy \n * Caps (capabilities) are lightweight objects describing media types. They are\n * composed of an array of {@link Structure}.\n * \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstCaps.html\n * \n * Caps are exposed on {@link PadTemplate} to describe all possible types a\n * given pad can handle. They are also stored in the {@link Registry} along with\n * a description of the {@link Element}.\n * \n * Caps are exposed on the element pads using the {@link Pad#getAllowedCaps() }\n * method. This method describes the possible types that the pad can handle or\n * produce at runtime.\n * \n * Caps are also attached to buffers to describe the content of the data pointed\n * to by the buffer with {@link Sample#setCaps}. Caps attached to a\n * {@link Buffer} allow for format negotiation upstream and downstream.\n * \n * A Caps can be constructed with the following code fragment:\n * \n * \n * A Caps is fixed when it has no properties with ranges or lists. Use\n * {@link #isFixed} to test for fixed caps. Only fixed caps can be set on a\n * {@link Pad} or {@link Buffer}.\n * \n * Various methods exist to work with the media types such as subtracting or\n * intersecting.\n *\n * @see Structure\n */\npublic class Caps extends MiniObject {\n\n public static final String GTYPE_NAME = \"GstCaps\";\n\n /**\n * Creates a new Caps that is empty. That is, the returned Caps contains no\n * media formats.\n *\n * @see #emptyCaps\n */\n public Caps() {\n this(Natives.initializer(GSTCAPS_API.ptr_gst_caps_new_empty()));\n }\n\n /**\n * Construct a new Caps from a string representation.\n *\n * @param caps The string representation of the caps.\n * @see #fromString\n */\n public Caps(String caps) {\n this(Natives.initializer(GSTCAPS_API.ptr_gst_caps_from_string(caps)));\n }\n\n /**\n * Create a caps that is a copy of another caps.\n *\n * @param caps The caps to copy.\n * @see #copy\n */\n public Caps(Caps caps) {\n this(Natives.initializer(GSTCAPS_API.ptr_gst_caps_copy(caps)));\n }\n\n Caps(Initializer init) {\n super(init);\n }\n\n /**\n * Append the structures contained in caps to this caps object. The\n * structures in caps are not copied -- they are transferred to this caps.\n * \n * If either caps is ANY, the resulting caps will be ANY.\n *\n * @param caps The Caps to append\n */\n public void append(Caps caps) {\n GSTCAPS_API.gst_caps_append(this, caps);\n }\n\n /**\n * Append structure to this caps. The structure is not copied; this caps\n * takes ownership, so do not use struct after calling this method.\n *\n * @param struct The structure to append.\n */\n public void append(Structure struct) {\n GSTCAPS_API.gst_caps_append_structure(this, struct);\n }\n\n /**\n * Create a new Caps as a copy of the this caps.\n *\n * The new Caps will be a copy of this caps, with all the internal\n * structures copied as well.\n *\n * @return The new Caps.\n */\n public Caps copy() {\n return GSTCAPS_API.gst_caps_copy(this);\n }\n\n @Override\n public boolean equals(Object other) {\n if (other == null || !(other instanceof Caps)) {\n return false;\n }\n return other == this || isEqual((Caps) other);\n }\n\n /**\n * Get a {@link Structure} contained in this caps.\n *\n * Finds the structure in @caps that has the index @index, and returns it.\n *\n * @param index The index of the structure to get.\n * @return The Structure corresponding to index.\n */\n public Structure getStructure(int index) {\n /*\n * WARNING: This function takes a const GstCaps *, but returns a\n * non-const GstStructure *. This is for programming convenience --\n * the caller should be aware that structures inside a constant\n * #GstCaps should not be modified.\n */\n // The above means we return a Structure proxy which does not own the pointer.\n // gst_caps_get_structure is not marked as CallerOwnsReturn, so it should work\n return GSTCAPS_API.gst_caps_get_structure(this, index);\n }\n\n /**\n * Creates a new {@link Caps} that contains all the formats that are common\n * to both this Caps and the other Caps.\n *\n * @param other The {@link Caps} to intersect with this one.\n *\n * @return The new {@link Caps}\n */\n public Caps intersect(Caps other) {\n return GSTCAPS_API.gst_caps_intersect(this, other);\n }\n\n /**\n * Check if this caps is always compatible with another caps.\n * \n * A given Caps structure is always compatible with another if every media\n * format that is in the first is also contained in the second. That is,\n * this caps1 is a subset of other.\n *\n * @param other The caps to test against.\n * @return true if other is always compatible with this caps.\n */\n public boolean isAlwaysCompatible(Caps other) {\n return GSTCAPS_API.gst_caps_is_always_compatible(this, other);\n }\n\n /**\n * Determine if this caps represents any media format.\n *\n * @return true if this caps represents any format.\n */\n public boolean isAny() {\n return GSTCAPS_API.gst_caps_is_any(this);\n }\n\n /**\n * Determine if this caps represents no media formats.\n *\n * @return true if this caps represents no formats.\n */\n public boolean isEmpty() {\n return GSTCAPS_API.gst_caps_is_empty(this);\n }\n\n /**\n * Checks if the given caps represent the same set of caps.\n * \n * This function does not work reliably if optional properties for caps are\n * included on one caps and omitted on the other.\n *\n * @param other The caps to compare this caps to.\n * @return true if other caps equals this one.\n */\n public boolean isEqual(Caps other) {\n return GSTCAPS_API.gst_caps_is_equal(this, other);\n }\n\n /**\n * Tests if two Caps are equal. This function only works on fixed Caps.\n *\n * @param other The other caps to test against.\n * @return true if the other caps is equal to this one.\n */\n public boolean isEqualFixed(Caps other) {\n return GSTCAPS_API.gst_caps_is_equal_fixed(this, other);\n }\n\n /**\n * Determine if this caps is fixed.\n * \n * Fixed Caps describe exactly one format, that is, they have exactly one\n * structure, and each field in the structure describes a fixed type.\n * Examples of non-fixed types are GST_TYPE_INT_RANGE and GST_TYPE_LIST.\n *\n * @return true if this caps is fixed\n */\n public boolean isFixed() {\n return GSTCAPS_API.gst_caps_is_fixed(this);\n }\n\n /**\n * Checks if all caps represented by this caps are also represented by\n * superset.\n * \n * This function does not work reliably if optional properties for caps are\n * included on one caps and omitted on the other.\n *\n * @param superset The potentially greater Caps\n * @return true if this caps is a subset of superset\n */\n public boolean isSubset(Caps superset) {\n return GSTCAPS_API.gst_caps_is_subset(this, superset);\n }\n\n /**\n *\n * Returns a writable copy of this caps.\n * \n * This method will invalidate the native side of this caps object, so it\n * should not be used after calling this method, and only the returned Caps\n * object should be used.\n * \n *\n * @return A writable version of this caps object.\n */\n // @TODO should this take a ref ?\n public Caps makeWritable() {\n return GSTCAPS_API.gst_caps_make_writable(this);\n }\n\n /**\n * Normalize the Caps.\n *\n * Creates a new {@link Caps} that represents the same set of formats as\n * this Caps, but contains no lists. Each list is expanded into separate\n * {@link Structure}s\n *\n * @return The new {@link Caps}\n * @see Structure\n */\n public Caps normalize() {\n// this.ref(); // gst_caps_normalize copies \"this\" and drops one reference\n Natives.ref(this);\n return GSTCAPS_API.gst_caps_normalize(this);\n }\n\n /**\n * Remove a structure from the caps. Removes the structure with the given\n * index from the list of structures contained in this caps.\n *\n * @param index Index of the structure to remove.\n */\n public void removeStructure(int index) {\n GSTCAPS_API.gst_caps_remove_structure(this, index);\n }\n\n public void setInteger(String field, Integer value) {\n GSTCAPS_API.gst_caps_set_simple(this, field, value, null);\n }\n\n /**\n * Modifies this caps inplace into a representation that represents the same\n * set of formats, but in a simpler form. Component structures that are\n * identical are merged. Component structures that have values that can be\n * merged are also merged.\n *\n * @return The new {@link Caps}\n */\n public Caps simplify() {\n// this.ref(); // gst_caps_simplify copies \"this\" and drops one reference\n Natives.ref(this);\n return GSTCAPS_API.gst_caps_simplify(this);\n }\n\n /**\n * Get the number of structures contained in this caps.\n *\n * @return the number of structures that this caps contains\n */\n public int size() {\n return GSTCAPS_API.gst_caps_get_size(this);\n }\n\n /**\n * Subtracts the subtrahend Caps from this Caps.\n *\n * \n * \n * Appends the structures contained in caps2 to caps1 if they are not yet\n * expressed by caps1 . The structures in caps2 are not copied -- they are\n * transferred to a writable copy of caps1 , and then caps2 is freed. If\n * either caps is ANY, the resulting caps will be ANY.\n * \n * GStreamer uses a global clock to synchronize the plugins in a pipeline.\n * Different clock implementations are possible by implementing this abstract\n * base class.\n * \n * The {@link Clock} returns a monotonically increasing time with the method\n * gst_clock_get_time(). Its accuracy and base time depend on the specific\n * clock implementation but time is always expressed in nanoseconds. Since the\n * baseline of the clock is undefined, the clock time returned is not\n * meaningful in itself, what matters are the deltas between two clock times.\n * The time returned by a clock is called the absolute time.\n * \n * The pipeline uses the clock to calculate the stream time. Usually all\n * renderers synchronize to the global clock using the buffer timestamps, the\n * newsegment events and the element's base time, see #GstPipeline.\n * \n * A clock implementation can support periodic and single shot clock\n * notifications both synchronous and asynchronous.\n * \n * One first needs to create a {@link ClockID} for the periodic or single shot\n * notification using {@link #newSingleShotID} or {@link #newPeriodicID}.\n * \n * To perform a blocking wait for the specific time of the {@link ClockID} use the\n * gst_clock_id_wait(). To receive a callback when the specific time is reached\n * in the clock use gst_clock_id_wait_async(). Both these calls can be\n * interrupted with the gst_clock_id_unschedule() call. If the blocking wait is\n * unscheduled a return value of GST_CLOCK_UNSCHEDULED is returned.\n * \n * Periodic callbacks scheduled async will be repeatedly called automatically\n * until it is unscheduled. To schedule a sync periodic callback,\n * gst_clock_id_wait() should be called repeatedly.\n * \n * The async callbacks can happen from any thread, either provided by the core\n * or from a streaming thread. The application should be prepared for this.\n * \n * A {@link ClockID} that has been unscheduled cannot be used again for any wait\n * operation, a new ClockID should be created.\n * \n * It is possible to perform a blocking wait on the same ClockID from\n * multiple threads. However, registering the same ClockID for multiple\n * async notifications is not possible, the callback will only be called for\n * the thread registering the entry last.\n * \n * These clock operations do not operate on the stream time, so the callbacks\n * will also occur when not in {@link State#PLAYING} state as if the clock just keeps on\n * running. Some clocks however do not progress when the element that provided\n * the clock is not {@link State#PLAYING}.\n * \n * When a clock has the GST_CLOCK_FLAG_CAN_SET_MASTER flag set, it can be\n * slaved to another #GstClock with the gst_clock_set_master(). The clock will\n * then automatically be synchronized to this master clock by repeatedly\n * sampling the master clock and the slave clock and recalibrating the slave\n * clock with {@link #setCalibration}. This feature is mostly useful for\n * plugins that have an internal clock but must operate with another clock\n * selected by the {@link Pipeline}. They can track the offset and rate difference\n * of their internal clock relative to the master clock by using the\n * gst_clock_get_calibration() function. \n * \n * The master/slave synchronisation can be tuned with the \"timeout\", \"window-size\"\n * and \"window-threshold\" properties. The \"timeout\" property defines the interval\n * to sample the master clock and run the calibration functions. \n * \"window-size\" defines the number of samples to use when calibrating and\n * \"window-threshold\" defines the minimum number of samples before the \n * calibration is performed.\n */\npublic class Clock extends GstObject {\n public static final String GTYPE_NAME = \"GstClock\";\n\n @Deprecated // should be package private\n public Clock(Initializer init) {\n super(init); \n }\n \n /**\n * Sets the accuracy of the clock. \n * \n * Some clocks have the possibility to operate with different accuracy at \n * the expense of more resource usage. There is normally no need to change \n * the default resolution of a clock. The resolution of a clock can only be \n * changed if the clock has the GST_CLOCK_FLAG_CAN_SET_RESOLUTION flag set.\n *\n * @param resolution the new resolution of the clock.\n * @return the new resolution of the clock.\n */\n public long setResolution(long resolution) {\n return GSTCLOCK_API.gst_clock_set_resolution(this, resolution);\n }\n \n /**\n * Gets the accuracy of the clock. The accuracy of the clock is the granularity\n * of the values returned by {@link #getTime}.\n *\n * @return the resolution of the clock in nanoseconds.\n */\n public long getResolution() {\n return GSTCLOCK_API.gst_clock_get_resolution(this);\n }\n \n /**\n * Gets the current time of the given clock. The time is always\n * monotonically increasing and adjusted according to the current\n * offset and rate.\n *\n * Returns: the time of the clock. Or GST_CLOCK_TIME_NONE when\n * giving wrong input.\n * @return the time of the clock. Or {@link ClockTime#NONE} when\n * given incorrect input.\n */\n public long getTime() {\n return GSTCLOCK_API.gst_clock_get_time(this);\n }\n /**\n * Gets the current internal time of this clock. The time is returned\n * unadjusted for the offset and the rate.\n *\n * Thread safe.\n * \n * @return the internal time of the clock. Or {@link ClockTime#NONE} when given wrong input.\n */\n public long getInternalTime() {\n return GSTCLOCK_API.gst_clock_get_internal_time(this);\n }\n \n /**\n * Gets the master clock that this clock is slaved to or null when the clock is\n * not slaved to any master clock.\n *\n * @return A master Clock or null when this clock is not slaved to a master\n * clock.\n */\n public Clock getMaster() {\n return GSTCLOCK_API.gst_clock_get_master(this);\n }\n \n /**\n * Set master as the master clock for this clock. This clock will be automatically\n * calibrated so that {@link #getTime} reports the same time as the\n * master clock. \n * \n * A clock provider that slaves its clock to a master can get the current\n * calibration values with {@link #getCalibration}.\n *\n * master can be null in which case clock will not be slaved anymore. It will\n * however keep reporting its time adjusted with the last configured rate \n * and time offsets.\n *\n * @param master a master Clock \n * @return true if the clock is capable of being slaved to a master clock. \n * Trying to set a master on a clock without the CAN_SET_MASTER flag will make \n * this function return false.\n */\n public boolean setMaster(Clock master) {\n return GSTCLOCK_API.gst_clock_set_master(this, master);\n }\n \n /**\n * Gets the internal rate and reference time of clock. See {@link #setCalibration} for more information.\n * \n * internal, external, rate_num, and rate_denom can be left NULL if the caller is not interested in the values.\n *\n * Thread safe.\n * @param internal a reference internal time\n * @param external a reference external time\n * @param rateNumerator the numerator of the rate of the clock relative to its internal time\n * @param rateDenominator the denominator of the rate of the clock\n */\n @Deprecated\n public void getCalibration(long internal, long external, long rateNumerator, long rateDenominator) {\n GSTCLOCK_API.gst_clock_set_calibration(this, internal, external, rateNumerator, rateDenominator);\n }\n \n /**\n * Gets the internal rate and reference time of clock. See\n * {@link #setCalibration} for more information.\n *\n * @return calibration\n */\n public Calibration getCalibration() {\n long[] internalPtr = new long[1];\n long[] externalPtr = new long[1];\n long[] rateNumPtr = new long[1];\n long[] rateDenomPtr = new long[1];\n GSTCLOCK_API.gst_clock_get_calibration(this, internalPtr,\n externalPtr, rateNumPtr, rateDenomPtr);\n return new Calibration(internalPtr[0], externalPtr[0],\n rateNumPtr[0], rateDenomPtr[0]);\n }\n \n /**\n * Adjusts the rate and time of this clock. A rate of 1/1 is the normal speed of\n * the clock. Values bigger than 1/1 make the clock go faster.\n * \n * internal and external are calibration parameters that arrange that\n * {@link #getTime} should have been external at internal time internal.\n * This internal time should not be in the future; that is, it should be less\n * than the value of {@link #getInternalTime} when this function is called.\n * \n * Subsequent calls to gst_clock_get_time() will return clock times computed as\n * follows:\n * \n * \n * This formula is implemented in gst_clock_adjust_unlocked(). Of course, it\n * tries to do the integer arithmetic as precisely as possible.\n * \n * Note that {@link #getTime} always returns increasing values so when you\n * move the clock backwards, getTime() will report the previous value\n * until the clock catches up.\n *\n * Thread safe.\n * @param internal a reference internal time\n * @param external a reference external time\n * @param rateNumerator the numerator of the rate of the clock relative to its internal time\n * @param rateDenominator the denominator of the rate of the clock\n */\n public void setCalibration(long internal, long external, long rateNumerator, long rateDenominator) {\n GSTCLOCK_API.gst_clock_set_calibration(this, internal, external, rateNumerator, rateDenominator);\n }\n \n /**\n * Gets a {@link ClockID} from this clock to trigger a single shot\n * notification at the requested time.\n * \n * Thread safe.\n * \n * @param time The requested time\n * @return A {@link ClockID} that can be used to request the time notification.\n */\n public ClockID newSingleShotID(long time) {\n return GSTCLOCK_API.gst_clock_new_single_shot_id(this, time);\n }\n \n /**\n * Gets an ID from this clock to trigger a periodic notification.\n * The periodeic notifications will be start at time start_time and\n * will then be fired with the given interval.\n * \n * Thread safe.\n * \n * @param startTime The requested start time.\n * @param interval The requested interval.\n * @return A {@link ClockID} that can be used to request the time notification.\n */\n public ClockID newPeriodicID(long startTime, long interval) {\n return GSTCLOCK_API.gst_clock_new_periodic_id(this, startTime, interval);\n }\n \n /**\n * Data storage for clock calibration.\n */\n public static final class Calibration {\n \n private final long internal;\n private final long external;\n private final long rateNum;\n private final long rateDenom;\n\n private Calibration(long internal, long external, long rateNum, long rateDenom) {\n this.internal = internal;\n this.external = external;\n this.rateNum = rateNum;\n this.rateDenom = rateDenom;\n }\n\n /**\n * The internal time.\n * \n * @return internal time\n */\n public long internal() {\n return internal;\n }\n\n /**\n * The external time.\n * \n * @return external time\n */\n public long external() {\n return external;\n }\n\n /**\n * The rate numerator.\n * \n * @return rate numerator\n */\n public long rateNum() {\n return rateNum;\n }\n\n /**\n * The rate denominator.\n * \n * @return rate denominator\n */\n public long rateDenom() {\n return rateDenom;\n }\n\n @Override\n public int hashCode() {\n int hash = 7;\n hash = 59 * hash + (int) (this.internal ^ (this.internal >>> 32));\n hash = 59 * hash + (int) (this.external ^ (this.external >>> 32));\n hash = 59 * hash + (int) (this.rateNum ^ (this.rateNum >>> 32));\n hash = 59 * hash + (int) (this.rateDenom ^ (this.rateDenom >>> 32));\n return hash;\n }\n\n @Override\n public boolean equals(Object obj) {\n if (this == obj) {\n return true;\n }\n if (obj == null) {\n return false;\n }\n if (getClass() != obj.getClass()) {\n return false;\n }\n final Calibration other = (Calibration) obj;\n if (this.internal != other.internal) {\n return false;\n }\n if (this.external != other.external) {\n return false;\n }\n if (this.rateNum != other.rateNum) {\n return false;\n }\n if (this.rateDenom != other.rateDenom) {\n return false;\n }\n return true;\n }\n\n @Override\n public String toString() {\n return \"Calibration{\" + \"internal=\" + internal + \", external=\" + external\n + \", rateNum=\" + rateNum + \", rateDenom=\" + rateDenom + '}';\n }\n \n \n }\n \n \n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/ClockID.java",
"content": "/* \n * Copyright (c) 2025 Neil C Smith\n * Copyright (c) 2007 Wayne Meissner\n * \n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under \n * the terms of the GNU Lesser General Public License version 3 only, as\n * published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT \n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or \n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License \n * version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * version 3 along with this work. If not, see \n * Thread safe.\n *\n * @return The time of this clock id.\n */\n public long getTime() {\n return GSTCLOCK_API.gst_clock_id_get_time(this);\n }\n\n /**\n * Compares this ClockID to another.\n *\n * @param other The other ClockID to compare to\n * @return negative value if\n * {@code a < b; zero if a = b; positive value if a > b}\n */\n @Override\n public int compareTo(ClockID other) {\n return GSTCLOCK_API.gst_clock_id_compare_func(this, other);\n }\n\n private static final class Handle extends RefCountedObject.Handle {\n\n public Handle(GPointer ptr, boolean ownsHandle) {\n super(ptr, ownsHandle);\n }\n\n @Override\n protected void disposeNativeHandle(GPointer ptr) {\n GSTCLOCK_API.gst_clock_id_unref(ptr);\n }\n\n @Override\n protected void ref() {\n GSTCLOCK_API.gst_clock_id_ref(getPointer());\n }\n\n @Override\n protected void unref() {\n GSTCLOCK_API.gst_clock_id_unref(getPointer());\n }\n\n }\n\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/ClockReturn.java",
"content": "/* \n * Copyright (C) 2019 Neil C Smith\n * Copyright (C) 2008 Wayne Meissner\n * Copyright (C) 1999,2000 Erik Walthinsen \n * See upstream documentation at https://gstreamer.freedesktop.org/documentation/gstreamer/gstcontext.html\n * \n * Context is a container object used to store contexts like a device context, a\n * display server connection and similar concepts that should be shared between\n * multiple elements.\n * \n * Applications can set a context on a complete pipeline by using\n * {@link Element#setContext(Context)}, which will then be propagated to all\n * child elements. Elements can handle these in\n * {@link Element#setContext(Context)} and merge them with the context\n * information they already have.\n * \n * When an element needs a context it will do the following actions in this\n * order until one step succeeds:\n * \n * Bins will catch GST_MESSAGE_NEED_CONTEXT messages and will set any previously\n * known context on the element that asks for it if possible. Otherwise the\n * application should provide one if it can.\n * \n * Contexts can be persistent. A persistent context is kept in elements when\n * they reach {@link State#NULL}, non-persistent ones will be removed. Also, a\n * non-persistent context won't override a previous persistent context set to an\n * element.\n */\npublic class Context extends MiniObject {\n\n public static final String GTYPE_NAME = \"GstContext\";\n\n private final Handle handle;\n\n public Context(String contextType) {\n this(contextType, true);\n }\n\n /**\n * Create a new context.\n */\n public Context(String context_type, boolean persistent) {\n this(new Handle(GstContextAPI.GSTCONTEXT_API.gst_context_new(context_type, persistent), true), false);\n }\n\n Context(Handle handle, boolean needRef) {\n super(handle, needRef);\n this.handle = handle;\n }\n\n Context(Initializer init) {\n this(new Handle(init.ptr.as(GstContextPtr.class, GstContextPtr::new), init.ownsHandle), init.needRef);\n }\n\n /**\n * Access the structure of the context.\n *\n * @return The structure of this context. The structure is still owned by this\n * context, which means that you should not modify it and not dispose of\n * it.\n */\n public Structure getStructure() {\n return GstContextAPI.GSTCONTEXT_API.gst_context_get_structure(handle.getPointer());\n }\n\n /**\n * Get a writable version of the structure.\n *\n * @return The structure of this context. The structure is still owned by the\n * context, which means that you should not dispose of it.\n */\n public Structure getWritableStructure() {\n return GstContextAPI.GSTCONTEXT_API.gst_context_writable_structure(handle.getPointer());\n }\n\n /**\n * Get the type of this context.\n *\n * @return The type of this context.\n */\n public String getContextType() {\n return GstContextAPI.GSTCONTEXT_API.gst_context_get_context_type(handle.getPointer());\n }\n\n protected static class Handle extends MiniObject.Handle {\n\n public Handle(GstContextPtr ptr, boolean ownsHandle) {\n super(ptr, ownsHandle);\n }\n\n @Override\n protected GstContextPtr getPointer() {\n return (GstContextPtr) super.getPointer();\n }\n\n }\n\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/ControlBinding.java",
"content": "/* \n * Copyright (c) 2019 Neil C Smith\n * \n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under \n * the terms of the GNU Lesser General Public License version 3 only, as\n * published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT \n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or \n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License \n * version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * version 3 along with this work. If not, see \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstControlBinding.html\n * \n */\npublic class ControlBinding extends GstObject {\n\n public static final String GTYPE_NAME = \"GstControlBinding\";\n \n private final Handle handle;\n\n protected ControlBinding(Handle handle, boolean needRef) {\n super(handle, needRef);\n this.handle = handle;\n }\n\n ControlBinding(Initializer init) {\n this(new Handle(\n init.ptr.as(GstControlBindingPtr.class, GstControlBindingPtr::new),\n init.ownsHandle),\n init.needRef);\n }\n\n /**\n * Gets the value for the given controlled property at the requested time.\n *\n * @param timestamp the time the control-change should be read from\n * @return the value of the property at the given time, or NULL if the\n * property isn't controlled\n */\n public Object getValue(long timestamp) {\n GValueAPI.GValue gValue = GSTCONTROLBINDING_API.gst_control_binding_get_value(\n handle.getPointer(), timestamp);\n return gValue == null ? null : gValue.getValue();\n }\n\n /**\n * Gets a number of values for the given controlled property starting at\n * the requested time.\n * \n * This function is useful if one wants to e.g. draw a graph of the control\n * curve or apply a control curve sample by sample.\n * \n * @param timestamp the time that should be processed\n * @param interval the time spacing between subsequent values\n * @param values array to fill with control values\n * @return false if the given array could not be filled\n */\n public boolean getValueArray(long timestamp, long interval, Object[] values) {\n GValueAPI.GValue[] gValues = new GValueAPI.GValue[values.length];\n boolean ok = GSTCONTROLBINDING_API.gst_control_binding_get_g_value_array(\n handle.getPointer(),\n timestamp,\n interval,\n gValues.length,\n gValues);\n if (ok) {\n for (int i = 0; i < values.length; i++) {\n values[i] = gValues[i].getValue();\n }\n }\n return ok;\n }\n \n /**\n * This function is used to disable a control binding for some time, i.e.\n * GstObject.syncValues() will do nothing.\n * \n * @param disabled whether to disable the controller or not\n */\n public void setDisabled(boolean disabled) {\n GSTCONTROLBINDING_API.gst_control_binding_set_disabled(handle.getPointer(), disabled);\n }\n \n /**\n * Check if the control binding is disabled.\n * \n * @return TRUE if the binding is inactive\n */\n public boolean isDisabled() {\n return GSTCONTROLBINDING_API.gst_control_binding_is_disabled(handle.getPointer());\n \n }\n \n\n protected static class Handle extends GstObject.Handle {\n\n public Handle(GstControlBindingPtr ptr, boolean ownsHandle) {\n super(ptr, ownsHandle);\n }\n\n @Override\n protected GstControlBindingPtr getPointer() {\n return (GstControlBindingPtr) super.getPointer();\n }\n\n }\n\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/ControlSource.java",
"content": "/* \n * Copyright (c) 2019 Neil C Smith\n * \n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under \n * the terms of the GNU Lesser General Public License version 3 only, as\n * published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT \n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or \n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License \n * version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * version 3 along with this work. If not, see \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstControlSource.html\n * \n */\npublic class ControlSource extends GstObject {\n \n public static final String GTYPE_NAME = \"GstControlSource\";\n\n private final Handle handle;\n\n protected ControlSource(Handle handle, boolean needRef) {\n super(handle, needRef);\n this.handle = handle;\n }\n\n ControlSource(Initializer init) {\n this(new Handle(\n init.ptr.as(GstControlSourcePtr.class, GstControlSourcePtr::new),\n init.ownsHandle),\n init.needRef);\n }\n\n /**\n * Gets the value for this ControlSource at a given timestamp.\n *\n * @param timestamp the time for which the value should be returned\n * @return value\n * @throws IllegalStateException if the value could not be calculated\n */\n public double getValue(long timestamp) {\n double[] out = new double[1];\n boolean ok = GSTCONTROLSOURCE_API.gst_control_source_get_value(handle.getPointer(), timestamp, out);\n if (ok) {\n return out[0];\n } else {\n throw new IllegalStateException();\n }\n }\n\n /**\n * Gets an array of values for for this ControlSource. Values that are\n * undefined contain NANs.\n *\n * @param timestamp the first timestamp\n * @param interval the time steps\n * @param values array to put control-values in\n * @return true if the values were successfully calculated\n */\n public boolean getValueArray(long timestamp, long interval, double[] values) {\n return GSTCONTROLSOURCE_API.gst_control_source_get_value_array(\n handle.getPointer(),\n timestamp,\n interval,\n values.length,\n values);\n }\n\n /**\n * A simple structure for saving a timestamp and a value.\n * \n * Equivalent to GstTimedValue.\n * \n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstControlSource.html#GstTimedValue\n *\n */\n public static final class TimedValue {\n\n public final long timestamp;\n public final double value;\n\n /**\n * Create a TimedValue wrapping the timestamp (see {@link ClockTime})\n * and corresponding value.\n *\n * @param timestamp the timestamp (GstClockTime) of the value change\n * @param value the corresponding value\n */\n public TimedValue(long timestamp, double value) {\n this.timestamp = timestamp;\n this.value = value;\n }\n\n @Override\n public int hashCode() {\n int hash = 7;\n hash = 37 * hash + (int) (this.timestamp ^ (this.timestamp >>> 32));\n hash = 37 * hash + (int) (Double.doubleToLongBits(this.value) ^ (Double.doubleToLongBits(this.value) >>> 32));\n return hash;\n }\n\n @Override\n public boolean equals(Object obj) {\n if (this == obj) {\n return true;\n }\n if (obj == null) {\n return false;\n }\n if (getClass() != obj.getClass()) {\n return false;\n }\n final TimedValue other = (TimedValue) obj;\n if (this.timestamp != other.timestamp) {\n return false;\n }\n if (Double.doubleToLongBits(this.value) != Double.doubleToLongBits(other.value)) {\n return false;\n }\n return true;\n }\n\n @Override\n public String toString() {\n return \"TimedValue{\" + \"timestamp=\" + timestamp + \", value=\" + value + '}';\n }\n\n }\n\n protected static class Handle extends GstObject.Handle {\n\n public Handle(GstControlSourcePtr ptr, boolean ownsHandle) {\n super(ptr, ownsHandle);\n }\n\n @Override\n protected GstControlSourcePtr getPointer() {\n return (GstControlSourcePtr) super.getPointer();\n }\n\n }\n\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/DateTime.java",
"content": "/* \n * Copyright (c) 2019 Neil C Smith\n * Copyright (c) 2016 Christophe Lafolet\n * Copyright (c) 2010 Levente Farkas\n * \n * This code is free software: you can redistribute it and/or modify it under \n * the terms of the GNU Lesser General Public License version 3 only, as\n * published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT \n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or \n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License \n * version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * version 3 along with this work. If not, see \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/documentation/gstreamer/gstelement.html\n * \n * Element is the abstract base class needed to construct an element that can be\n * used in a GStreamer pipeline. Please refer to the plugin writers guide for\n * more information on creating Element subclasses.\n * \n * The name of a Element can be retrieved with {@link #getName} and set with\n * {@link #setName}.\n * \n * All elements have pads (of the type {@link Pad}). These pads link to pads on\n * other elements. {@link Buffer}s flow between these linked pads. An Element\n * has a list of {@link Pad} structures for all their input (or sink) and output\n * (or source) pads. Core and plug-in writers can add and remove pads with\n * {@link #addPad} and {@link #removePad}.\n * \n * Elements can be linked through their pads. If the link is straightforward,\n * use the {@link #link} convenience function to link two elements, or\n * {@link #linkMany} for more elements in a row.\n * \n * For finer control, use {@link #linkPads} and {@link #linkPadsFiltered} to\n * specify the pads to link on each element by name.\n * \n * Each element has a state (see {@link State}). You can get and set the state\n * of an element with {@link #getState} and {@link #setState}.\n *\n */\npublic class Element extends GstObject {\n\n public static final String GTYPE_NAME = \"GstElement\";\n\n /**\n * Creates a new instance of Element. This constructor is used internally.\n *\n * @param init internal initialization data.\n */\n protected Element(Initializer init) {\n super(init);\n }\n\n Element(Handle handle, boolean needRef) {\n super(handle, needRef);\n }\n\n /**\n * Creates an instance of the required element type, but does not wrap it in\n * a proxy.\n *\n * @param factoryName The name of the factory to use to produce the Element\n * @param elementName The name to assign to the created Element\n * @return a raw element.\n */\n protected static Initializer makeRawElement(String factoryName, String elementName) {\n return Natives.initializer(ElementFactory.makeRawElement(factoryName, elementName));\n }\n\n /**\n * Links this element to another element. The link must be from source to\n * destination; the other direction will not be tried.\n * \n * The function looks for existing pads that aren't linked yet. It will\n * request new pads if necessary. Such pads need to be released manually\n * when unlinking. If multiple links are possible, only one is established.\n * \n * Make sure you have added your elements to a bin or pipeline with\n * {@link Bin#add} or {@link Bin#addMany} before trying to link them.\n * \n * See {@link #linkPadsFiltered} if you need more control about which pads\n * are selected for linking.\n *\n * @param dest The element containing the destination pad.\n * @return true if the elements could be linked, false otherwise.\n */\n public boolean link(Element dest) {\n return GSTELEMENT_API.gst_element_link(this, dest);\n }\n\n /**\n * Links this element to another element using the given caps as filtercaps.\n * The link must be from source to destination; the other direction will not\n * be tried.\n * \n * The function looks for existing pads that aren't linked yet. It will\n * request new pads if necessary. Such pads need to be released manually\n * when unlinking. If multiple links are possible, only one is established.\n * \n * Make sure you have added your elements to a bin or pipeline with\n * {@link Bin#add} or {@link Bin#addMany} before trying to link them.\n * \n * See {@link #linkPadsFiltered} if you need more control about which pads\n * are selected for linking.\n *\n * @param dest The element containing the destination pad.\n * @param filter The {@link Caps} to filter the link, or Null for no filter.\n * @return true if the elements could be linked, false otherwise.\n */\n public boolean linkFiltered(Element dest, Caps filter) {\n return GSTELEMENT_API.gst_element_link_filtered(this, dest, filter);\n }\n\n /**\n * Unlinks all source pads of this source element with all sink pads of the\n * sink element to which they are linked.\n * \n * If the link has been made using {@link #link}, it could have created an\n * requestpad, which has to be released using\n * gst_element_release_request_pad().\n *\n * @param dest The sink Element to unlink.\n */\n public void unlink(Element dest) {\n GSTELEMENT_API.gst_element_unlink(this, dest);\n }\n\n /**\n * Tests if the Element is currently playing.\n *\n * @return true if the Element is currently playing\n */\n public boolean isPlaying() {\n return getState() == State.PLAYING;\n }\n\n /**\n * Tells the Element to start playing the media stream. Equivalent to\n * calling {@link #setState(org.freedesktop.gstreamer.State)} with\n * {@link State#PLAYING}.\n *\n * @return the status of the element's state change.\n */\n public StateChangeReturn play() {\n return setState(State.PLAYING);\n }\n\n /**\n * Tells the Element to set ready the media stream. Equivalent to calling\n * {@link #setState(org.freedesktop.gstreamer.State)} with\n * {@link State#READY}.\n *\n * @return the status of the element's state change.\n */\n public StateChangeReturn ready() {\n return setState(State.READY);\n }\n\n /**\n * Tells the Element to pause playing the media stream. Equivalent to\n * calling {@link #setState(org.freedesktop.gstreamer.State)} with\n * {@link State#PAUSED}.\n *\n * @return the status of the element's state change.\n */\n public StateChangeReturn pause() {\n return setState(State.PAUSED);\n }\n\n /**\n * Tells the Element to stop playing the media stream. Equivalent to calling\n * {@link #setState(org.freedesktop.gstreamer.State)} with\n * {@link State#NULL}.\n *\n * @return the status of the element's state change.\n */\n public StateChangeReturn stop() {\n return setState(State.NULL);\n }\n\n /**\n * Sets the state of the element.\n * \n * This method will try to set the requested state by going through all the\n * intermediary states.\n * \n * This function can return {@link StateChangeReturn#ASYNC}, in which case\n * the element will perform the remainder of the state change asynchronously\n * in another thread.\n * \n * An application can use {@link #getState} to wait for the completion of\n * the state change or it can wait for a state change message on the bus.\n *\n * @param state the element's new {@link State}.\n * @return the status of the element's state change.\n */\n public StateChangeReturn setState(State state) {\n return GSTELEMENT_API.gst_element_set_state(this, state);\n }\n\n /**\n * Locks the state of an element, so state changes of the parent don't\n * affect this element anymore.\n *\n * @param locked_state true to lock the element's {@link State}.\n * @return true if the state was changed, false if bad parameters were given\n * or the elements state-locking needed no change.\n */\n public boolean setLockedState(boolean locked_state) {\n return GSTELEMENT_API.gst_element_set_locked_state(this, locked_state);\n }\n\n /**\n * Gets the state of the element.\n * \n * This method will wait until any async state change has completed.\n *\n * @return The {@link State} the Element is currently in.\n */\n public State getState() {\n return getState(-1);\n }\n\n /**\n * Gets the state of the element.\n * \n * For elements that performed an ASYNC state change, as reported by\n * {@link #setState(org.freedesktop.gstreamer.State)}, this function will\n * block up to the specified timeout value for the state change to complete.\n *\n * @param timeout the amount of time to wait.\n * @param units the units of the timeout.\n * @return The {@link State} the Element is currently in.\n *\n */\n public State getState(long timeout, TimeUnit units) {\n State[] state = new State[1];\n GSTELEMENT_API.gst_element_get_state(this, state, null, units.toNanos(timeout));\n return state[0];\n }\n\n /**\n * Gets the state of the element.\n * \n * For elements that performed an ASYNC state change, as reported by\n * {@link #setState(org.freedesktop.gstreamer.State)}, this function will\n * block up to the specified timeout value for the state change to complete.\n *\n * @param timeout The amount of time in nanoseconds to wait.\n * @return The {@link State} the Element is currently in.\n *\n */\n public State getState(long timeout) {\n State[] state = new State[1];\n GSTELEMENT_API.gst_element_get_state(this, state, null, timeout);\n return state[0];\n }\n\n /**\n * Gets the state of the element.\n * \n * For elements that performed an ASYNC state change, as reported by\n * {@link #setState(org.freedesktop.gstreamer.State)}, this function will\n * block up to the specified timeout value for the state change to complete.\n *\n * @param timeout The amount of time in nanoseconds to wait.\n * @param states an array to store the states in. Must be of sufficient size\n * to hold two elements.\n */\n public void getState(long timeout, State[] states) {\n State[] state = new State[1];\n State[] pending = new State[1];\n GSTELEMENT_API.gst_element_get_state(this, state, pending, timeout);\n states[0] = state[0];\n states[1] = pending[0];\n }\n\n /**\n * Tries to change the state of the element to the same as its parent. If\n * this function returns false, the state of element is undefined.\n *\n * @return true, if the element's state could be synced to the parent's\n * state. MT safe.\n */\n public boolean syncStateWithParent() {\n return GSTELEMENT_API.gst_element_sync_state_with_parent(this);\n }\n\n /**\n * Sets the {@link Caps} on this Element.\n *\n * @param caps the new Caps to set.\n */\n public void setCaps(Caps caps) {\n GOBJECT_API.g_object_set(this, \"caps\", caps);\n }\n\n /**\n * Retrieves a pad from the element by name. This version only retrieves\n * already-existing (i.e. 'static') pads.\n *\n * @param padname The name of the {@link Pad} to get.\n * @return The requested {@link Pad} if found, otherwise null.\n */\n public Pad getStaticPad(String padname) {\n return GSTELEMENT_API.gst_element_get_static_pad(this, padname);\n }\n\n /**\n * Retrieves a list of the element's pads.\n *\n * @return the List of {@link Pad}s.\n */\n public List \n * Pads are not automatically activated so elements should perform the\n * needed steps to activate the pad in case this pad is added in the PAUSED\n * or PLAYING state. See {@link Pad#setActive} for more information about\n * activating pads.\n * \n * This function will emit the {@link PAD_ADDED} signal on the element.\n *\n * @param pad The {@link Pad} to add.\n * @return true if the pad could be added. This function can fail when a pad\n * with the same name already existed or the pad already had another parent.\n */\n public boolean addPad(Pad pad) {\n return GSTELEMENT_API.gst_element_add_pad(this, pad);\n }\n\n /**\n * Retrieves a pad from the element by name. This version only retrieves\n * request pads. The pad must be released with {@link #releaseRequestPad}.\n *\n * @param name the name of the request {@link Pad} to retrieve.\n * @return the requested Pad if found, otherwise null. Release\n * using {@link #releaseRequestPad} after usage.\n */\n public Pad getRequestPad(String name) {\n return GSTELEMENT_API.gst_element_get_request_pad(this, name);\n }\n\n /**\n * Frees the previously requested pad obtained via {@link #getRequestPad}.\n *\n * @param pad the pad to release.\n */\n public void releaseRequestPad(Pad pad) {\n GSTELEMENT_API.gst_element_release_request_pad(this, pad);\n }\n\n /**\n * Remove a {@link Pad} from the element.\n * \n * This method is used by plugin developers and should not be used by\n * applications. Pads that were dynamically requested from elements with\n * {@link #getRequestPad} should be released with the\n * {@link #releaseRequestPad} function instead.\n * \n * Pads are not automatically deactivated so elements should perform the\n * needed steps to deactivate the pad in case this pad is removed in the\n * PAUSED or PLAYING state. See {@link Pad#setActive} for more information\n * about deactivating pads.\n * \n * This function will emit the {@link PAD_REMOVED} signal on the element.\n *\n * @param pad The {@link Pad} to remove.\n * @return true if the pad could be removed. Can return false if the pad\n * does not belong to the provided element.\n */\n public boolean removePad(Pad pad) {\n return GSTELEMENT_API.gst_element_remove_pad(this, pad);\n }\n\n /**\n * Retrieves the factory that was used to create this element.\n *\n * @return the {@link ElementFactory} used for creating this element.\n */\n public ElementFactory getFactory() {\n return GSTELEMENT_API.gst_element_get_factory(this);\n }\n\n /**\n * Get the bus of the element. Note that only a {@link Pipeline} will\n * provide a bus for the application.\n *\n * @return the element's {@link Bus}\n */\n public Bus getBus() {\n return GSTELEMENT_API.gst_element_get_bus(this);\n }\n\n /**\n * Sends an event to an element.\n * \n * If the element doesn't implement an event handler, the event will be\n * pushed on a random linked sink pad for upstream events or a random linked\n * source pad for downstream events.\n *\n * @param ev The {@link Event} to send.\n * @return true if the event was handled.\n */\n public boolean sendEvent(Event ev) {\n return GSTELEMENT_API.gst_element_send_event(this, ev);\n }\n\n /**\n * Signal emitted when an {@link Pad} is added to this element.\n *\n * @see #connect(PAD_ADDED)\n * @see #disconnect(PAD_ADDED)\n */\n public static interface PAD_ADDED {\n\n /**\n * Called when a new {@link Pad} is added to an Element.\n *\n * @param element the element the pad was added to.\n * @param pad the pad which was added.\n */\n public void padAdded(Element element, Pad pad);\n }\n\n /**\n * Signal emitted when an {@link Pad} is removed from this element.\n *\n * @see #connect(PAD_REMOVED)\n * @see #disconnect(PAD_REMOVED)\n */\n public static interface PAD_REMOVED {\n\n /**\n * Called when a new {@link Pad} is removed from an Element.\n *\n * @param element the element the pad was removed from.\n * @param pad the pad which was removed.\n */\n public void padRemoved(Element element, Pad pad);\n }\n\n /**\n * Signal emitted when this element ceases to generated dynamic pads.\n *\n * @see #connect(NO_MORE_PADS)\n * @see #disconnect(NO_MORE_PADS)\n */\n public static interface NO_MORE_PADS {\n\n /**\n * Called when an element ceases to generated dynamic pads.\n *\n * @param element the element which posted this message.\n */\n public void noMorePads(Element element);\n }\n\n /**\n * Add a listener for the \n * Make sure you have added your elements to a bin or pipeline with\n * {@link Bin#add} or {@link Bin#addMany} before trying to link them.\n *\n * @param elements The list of elements to link together.\n * @return true if all elements successfully linked.\n */\n public static boolean linkMany(Element... elements) {\n return GSTELEMENT_API.gst_element_link_many(elements);\n }\n\n /**\n * Unlink a list of elements.\n *\n * @param elements The list of elements to link together\n *\n */\n public static void unlinkMany(Element... elements) {\n GSTELEMENT_API.gst_element_unlink_many(elements);\n }\n\n /**\n * Link together source and destination pads of two elements.\n *\n * A side effect is that if one of the pads has no parent, it becomes a\n * child of the parent of the other element. If they have different parents,\n * the link fails.\n *\n * @param src The element containing the source {@link Pad}.\n * @param srcPadName The name of the source {@link Pad}. Can be null for any\n * pad.\n * @param dest The element containing the destination {@link Pad}.\n * @param destPadName The name of the destination {@link Pad}. Can be null\n * for any pad.\n *\n * @return true if the pads were successfully linked.\n */\n public static boolean linkPads(Element src, String srcPadName, Element dest, String destPadName) {\n return GSTELEMENT_API.gst_element_link_pads(src, srcPadName, dest, destPadName);\n }\n\n /**\n * Link together source and destination pads of two elements. A side effect\n * is that if one of the pads has no parent, it becomes a child of the\n * parent of the other element. If they have different parents, the link\n * fails. If caps is not null, makes sure that the caps of the link is a\n * subset of caps.\n *\n * @param src The element containing the source {@link Pad}.\n * @param srcPadName The name of the source {@link Pad}. Can be null for any\n * pad.\n * @param dest The element containing the destination {@link Pad}.\n * @param destPadName The name of the destination {@link Pad}. Can be null\n * for any pad.\n * @param caps The {@link Caps} to use to filter the link.\n *\n * @return true if the pads were successfully linked.\n */\n public static boolean linkPadsFiltered(Element src, String srcPadName,\n Element dest, String destPadName, Caps caps) {\n return GSTELEMENT_API.gst_element_link_pads_filtered(src, srcPadName, dest, destPadName, caps);\n }\n\n /**\n * Unlink source and destination pads of two elements.\n *\n * @param src The element containing the source {@link Pad}.\n * @param srcPadName The name of the source {@link Pad}.\n * @param dest The element containing the destination {@link Pad}.\n * @param destPadName The name of the destination {@link Pad}.\n *\n */\n public static void unlinkPads(Element src, String srcPadName, Element dest, String destPadName) {\n GSTELEMENT_API.gst_element_unlink_pads(src, srcPadName, dest, destPadName);\n }\n\n /**\n * Posts a {@link Message} on the element's {@link Bus}.\n *\n * @param message the Message to post.\n * @return true if the message was posted, false if the\n * element does not have a {@link Bus}.\n */\n public boolean postMessage(Message message) {\n return GSTELEMENT_API.gst_element_post_message(this, message);\n }\n\n /**\n * Gets the currently configured clock of the element.\n *\n * @return the clock of the element.\n */\n public Clock getClock() {\n return GSTELEMENT_API.gst_element_get_clock(this);\n }\n\n /**\n * Returns the base time of the element. The base time is the absolute time\n * of the clock when this element was last put to PLAYING. Subtracting the\n * base time from the clock time gives the stream time of the element.\n *\n * @return the base time of the element\n */\n public long getBaseTime() {\n return GSTELEMENT_API.gst_element_get_base_time(this);\n }\n\n /**\n * Set the base time of an element.\n *\n * @param time the base time to set\n * @see #getBaseTime()\n */\n public void setBaseTime(long time) {\n GSTELEMENT_API.gst_element_set_base_time(this, time);\n }\n\n /**\n * Returns the start time of this element.\n *\n * The start time is the running time of the clock when this element was\n * last put to {@link State#PAUSED}. Usually the start_time is managed by a\n * toplevel element such as {@link Pipeline}.\n *\n * MT safe.\n *\n * @return the start time of this element.\n */\n public long getStartTime() {\n return GSTELEMENT_API.gst_element_get_start_time(this);\n }\n\n /**\n * Set the start time of an element. The start time of the element is the\n * running time of the element when it last went to the {@link State#PAUSED}\n * state. In {@link State#READY} or after a flushing seek, it is set to 0.\n *\n * Toplevel elements like GstPipeline will manage the start_time and\n * base_time on its children. Setting the start_time to\n * {@link ClockTime#NONE} on such a toplevel element will disable the\n * distribution of the base_time to the children and can be useful if the\n * application manages the base_time itself, for example if you want to\n * synchronize capture from multiple pipelines, and you can also ensure that\n * the pipelines have the same clock.\n *\n * MT safe.\n *\n * @param time the start time to set\n * @see #getStartTime()\n */\n public void setStartTime(long time) {\n GSTELEMENT_API.gst_element_set_start_time(this, time);\n }\n\n /**\n * Performs a query on the element.\n *\n * For elements that don't implement a query handler, this function forwards\n * the query to a random srcpad or to the peer of a random linked sinkpad of\n * this element.\n *\n * Please note that some queries might need a running pipeline to work.\n *\n * @param query the Query to perform\n * @return true if the query could be performed\n */\n public boolean query(Query query) {\n return GSTELEMENT_API.gst_element_query(this, query);\n }\n\n /**\n * Sets the context of the element.\n *\n * @param context the Context to set.\n */\n public void setContext(Context context) {\n GstContextPtr gstContextPtr = Natives.getPointer(context).as(GstContextPtr.class, GstContextPtr::new);\n GSTELEMENT_API.gst_element_set_context(this, gstContextPtr);\n }\n\n /**\n * Gets the context with the context_type set on the element or NULL.\n *\n * @param context_type\n * @return a context or NULL\n */\n public Context getContext(String context_type) {\n GstContextPtr gstContextPtr = GSTELEMENT_API.gst_element_get_context(this, context_type);\n return gstContextPtr != null ? Natives.callerOwnsReturn(gstContextPtr, Context.class) : null;\n }\n\n /**\n * Queries an element (usually top-level pipeline or playbin element) for\n * the total stream duration in nanoseconds. This query will only work once\n * the pipeline is prerolled (i.e. reached PAUSED or PLAYING state). The\n * application will receive an ASYNC_DONE message on the pipeline bus when\n * that is the case.\n * \n * If the duration changes for some reason, you will get a DURATION_CHANGED\n * message on the pipeline bus, in which case you should re-query the\n * duration using this function.\n *\n * @param format the {@code Format} to return the duration in\n * @return the total duration of the current media stream, or -1 if the\n * query failed\n */\n public long queryDuration(Format format) {\n long[] dur = {0};\n return GSTELEMENT_API.gst_element_query_duration(this, format, dur) ? dur[0] : -1L;\n }\n\n /**\n * Queries an element (usually top-level pipeline or playbin element) for\n * the stream position in nanoseconds. This will be a value between 0 and\n * the stream duration (if the stream duration is known). This query will\n * usually only work once the pipeline is prerolled (i.e. reached PAUSED or\n * PLAYING state). The application will receive an ASYNC_DONE message on the\n * pipeline bus when that is the case.\n *\n * @param format The {@link Format} to return the position in\n * @return the current position or -1 if the query failed.\n */\n public long queryPosition(Format format) {\n long[] pos = {0};\n return GSTELEMENT_API.gst_element_query_position(this, format, pos) ? pos[0] : -1L;\n }\n\n /**\n * Sends a seek event to an element. See {@link SeekEvent} for the details\n * of the parameters. The seek event is sent to the element using the native\n * equivalent of {@link #sendEvent(org.freedesktop.gstreamer.event.Event)}.\n *\n * @param rate the new playback rate\n * @param format the format of the seek values\n * @param seekFlags the seek flags\n * @param startType the type and flags for the new start position\n * @param start the value of the new start position\n * @param stopType the type and flags for the new stop position\n * @param stop the value of the new stop position\n * @return true if seek operation succeeded. Flushing seeks will trigger a\n * preroll, which will emit an ASYNC_DONE message\n */\n public boolean seek(double rate, Format format, Set \n * In a completely prerolled PAUSED or PLAYING pipeline, seeking is always\n * guaranteed to return TRUE on a seekable media type or FALSE when the\n * media type is certainly not seekable (such as a live stream).\n * \n * Some elements allow for seeking in the READY state, in this case they\n * will store the seek event and execute it when they are put to PAUSED. If\n * the element supports seek in READY, it will always return TRUE when it\n * receives the event in the READY state.\n *\n * @param format a {@link Format} to seek in, such as {@link Format#TIME}\n * @param seekFlags seek options; playback applications will usually want to\n * use {@link SeekFlags#FLUSH} and {@link SeekFlags#KEY_UNIT} here\n * @param seekPosition position to seek to (relative to the start); if you\n * are doing a seek in format TIME this value is in nanoseconds\n * @return true if seek operation succeeded. Flushing seeks will trigger a\n * preroll, which will emit an ASYNC_DONE message\n */\n public boolean seekSimple(Format format, Set \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstElementFactory.html\n * \n * Use the {@link #find} and {@link #create} methods to create element instances\n * or use {@link #make} as a convenient shortcut.\n *\n */\npublic class ElementFactory extends PluginFeature {\n\n public static final String GTYPE_NAME = \"GstElementFactory\";\n \n private static final Level DEBUG = Level.FINE;\n private static final Logger LOG = Logger.getLogger(ElementFactory.class.getName());\n\n /**\n * Creates a new instance of ElementFactory\n *\n * @param init internal initialization data.\n */\n ElementFactory(Initializer init) {\n super(init);\n if (LOG.isLoggable(Level.FINER)) {\n LOG.entering(\"ElementFactory\", \" \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstPad.html#GstFlowReturn\n * \n */\npublic enum FlowReturn implements NativeEnum \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/gstreamer-GstFormat.html#GstFormat\n * \n */\n// @TODO this won't handle custom registered formats - do we need to?\npublic enum Format implements NativeEnum \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstGhostPad.html\n * \n * GhostPads are useful when organizing pipelines with {@link Bin} like\n * elements. The idea here is to create hierarchical element graphs. The bin\n * element contains a sub-graph. Now one would like to treat the bin-element\n * like any other {@link Element}. This is where GhostPads come into play. A\n * GhostPad acts as a proxy for another pad. Thus the bin can have sink and\n * source ghost-pads that are associated with sink and source pads of the child\n * elements.\n * \n * If the target pad is known at creation time, {@link #GhostPad(String, Pad)}\n * is the function to use to get a ghost-pad. Otherwise one can use\n * {@link #GhostPad(String, PadDirection)} to create the ghost-pad and use\n * {@link #setTarget} to establish the association later on.\n * \n * Note that GhostPads add overhead to the data processing of a pipeline.\n *\n * @see Pad\n */\npublic class GhostPad extends Pad {\n\n public static final String GTYPE_NAME = \"GstGhostPad\";\n\n /**\n * Creates a new instance of GhostPad\n */\n GhostPad(Initializer init) {\n super(init);\n }\n\n /**\n * Create a new ghostpad with target as the target. The direction will be\n * taken from the target pad. The target pad must be unlinked.\n *\n * @param name The name of the new pad, or null to assign a default name.\n * @param target The {@link Pad} to ghost.\n */\n public GhostPad(String name, Pad target) {\n this(Natives.initializer(GSTGHOSTPAD_API.ptr_gst_ghost_pad_new(name, target)));\n }\n\n /**\n * Create a new ghostpad with target as the target. The direction will be\n * taken from the target pad. The template used on the ghostpad will be\n * template.\n *\n * @param name The name of the new pad, or null to assign a default name.\n * @param target The {@link Pad} to ghost.\n * @param template The {@link PadTemplate} to use on the ghostpad.\n */\n public GhostPad(String name, Pad target, PadTemplate template) {\n this(Natives.initializer(GSTGHOSTPAD_API.ptr_gst_ghost_pad_new_from_template(name, target, template)));\n }\n\n /**\n * Create a new ghostpad without a target with the given direction. A target\n * can be set on the ghostpad later with the {@link #setTarget} method.\n * \n * The created ghostpad will not have a padtemplate.\n *\n * @param name The name of the new pad, or null to assign a default name.\n * @param direction The direction of the ghostpad.\n */\n public GhostPad(String name, PadDirection direction) {\n this(Natives.initializer(GSTGHOSTPAD_API.ptr_gst_ghost_pad_new_no_target(name, direction.ordinal())));\n }\n\n /**\n * Create a new ghostpad based on template, without setting a target. The\n * direction will be taken from the template.\n *\n * @param name The name of the new pad, or null to assign a default name.\n * @param template The {@link PadTemplate} to use on the ghostpad.\n */\n public GhostPad(String name, PadTemplate template) {\n this(Natives.initializer(GSTGHOSTPAD_API.ptr_gst_ghost_pad_new_no_target_from_template(name, template)));\n }\n\n /**\n * Get the target pad of this ghostpad.\n *\n * @return the target {@link Pad}, can be null if the ghostpad has no target\n * set\n */\n public Pad getTarget() {\n return GSTGHOSTPAD_API.gst_ghost_pad_get_target(this);\n }\n\n /**\n * Set the new target of the ghostpad. Any existing target is unlinked and\n * links to the new target are established.\n *\n * @param pad The new pad target.\n * @return true if the new target could be set. This function can return\n * false when the internal pads could not be linked.\n */\n public boolean setTarget(Pad pad) {\n return GSTGHOSTPAD_API.gst_ghost_pad_set_target(this, pad);\n }\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/Gst.java",
"content": "/* \n * Copyright (c) 2025 Neil C Smith\n * Copyright (c) 2018 Antonio Morales\n * Copyright (c) 2007 Wayne Meissner\n * \n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under \n * the terms of the GNU Lesser General Public License version 3 only, as\n * published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT \n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or \n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License \n * version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * version 3 along with this work. If not, see \n * Applications might want to disable this behaviour with the\n * {@link #setSegTrap(boolean) } function. This is typically done if the\n * application wants to install its own handler without GStreamer\n * interfering.\n *\n * @return Segmentation Trap status.\n */\n public static boolean isSegTrapEnabled() {\n return GST_API.gst_segtrap_is_enabled();\n }\n\n /**\n * Applications might want to disable/enable the SIGSEGV handling of the\n * GStreamer core. See {@link #isSegTrapEnabled() } for more information.\n *\n * @param enabled\n */\n public static void setSegTrap(boolean enabled) {\n GST_API.gst_segtrap_set_enabled(enabled);\n }\n\n /**\n * Test whether the GStreamer library already initialized.\n *\n * @return true if the GStreamer library already initialized.\n */\n public static synchronized final boolean isInitialized() {\n return INIT_COUNT.get() > 0;\n }\n\n /**\n * Gets the common {@link ScheduledExecutorService} used to execute\n * background tasks and schedule timeouts.\n *\n * @return an executor that can be used for background tasks.\n */\n public static ScheduledExecutorService getExecutor() {\n return executorService;\n }\n\n /**\n * Signals the thread that called {@link #init} to return.\n */\n public static void quit() {\n quit.countDown();\n }\n\n /**\n * Create a new pipeline based on command line syntax.\n *\n * Please note that you might get a return value that is not NULL even\n * though the error is set. In this case there was a recoverable parsing\n * error and you can try to play the pipeline.\n *\n * @param pipelineDescription the command line describing the pipeline\n * @param errors a list that any errors will be added to\n * @return a new element on success. If more than one top-level element is\n * specified by the pipeline_description , all elements are put into a\n * Pipeline, which then is returned.\n * @throws GstException if the pipeline / element could not be created\n */\n public static Element parseLaunch(String pipelineDescription, List \n * For most gui programs, this is of little use. However, it can be a\n * convenient way of keeping the main thread alive whilst gstreamer\n * processing on other threads continues.\n */\n public static void main() {\n try {\n CountDownLatch latch = quit;\n if (latch != null) {\n latch.await();\n }\n } catch (InterruptedException ex) {\n } finally {\n quit = new CountDownLatch(1);\n }\n }\n\n /**\n * Schedules a task for execution on the gstreamer background\n * {@link java.util.concurrent.Executor}.\n *\n * @param task the task to execute.\n */\n public static void invokeLater(final Runnable task) {\n getExecutor().execute(task);\n }\n\n\n /**\n * Gets the current main context used (if any).\n *\n * @return a main context.\n */\n // @TODO leaking lowlevel\n public static GMainContext getMainContext() {\n return mainContext;\n }\n\n /**\n * Initializes the GStreamer library.\n * \n * This is a shortcut if no arguments are to be passed to gstreamer.\n * \n * This is equivalent to calling\n * {@link #init(org.freedesktop.gstreamer.Version) } with\n * {@link Version#BASELINE}, currently GStreamer 1.8. If you require\n * features from a later version of GStreamer you should specify the\n * required version.\n *\n * @throws org.freedesktop.gstreamer.GstException\n */\n public static final void init() throws GstException {\n init(Version.BASELINE, \"gst1-java-core\");\n }\n\n /**\n * Initializes the GStreamer library.\n * \n * This is a shortcut if no arguments are to be passed to gstreamer.\n *\n * @param requiredVersion\n * @throws org.freedesktop.gstreamer.GstException\n */\n public static final void init(Version requiredVersion) throws GstException {\n init(requiredVersion, \"gst1-java-core\");\n }\n\n /**\n * Initializes the GStreamer library.\n * \n * This sets up internal path lists, registers built-in elements, and loads\n * standard plugins.\n * \n * This is equivalent to calling\n * {@link #init(org.freedesktop.gstreamer.Version, java.lang.String, java.lang.String...) }\n * with {@link Version#BASELINE}, currently GStreamer 1.8. If you\n * require features from a later version of GStreamer you should specify the\n * required version.\n *\n * @param progname the java program name.\n * @param args the java argument list.\n * @return the list of arguments with any gstreamer specific options\n * stripped out.\n * @throws org.freedesktop.gstreamer.GstException\n */\n public static synchronized final String[] init(String progname, String... args) throws GstException {\n return init(Version.BASELINE, progname, args);\n }\n\n /**\n * Initializes the GStreamer library.\n * \n * This sets up internal path lists, registers built-in elements, and loads\n * standard plugins.\n *\n * @param requestedVersion the minimum requested GStreamer version.\n * @param progname the java program name.\n * @param args the java argument list.\n * @return the list of arguments with any gstreamer specific options\n * stripped out.\n * @throws org.freedesktop.gstreamer.GstException\n */\n public static synchronized final String[] init(Version requestedVersion,\n String progname, String... args) throws GstException {\n \n if (CHECK_VERSIONS) {\n Version availableVersion = getVersion();\n if (requestedVersion.getMajor() != 1 || availableVersion.getMajor() != 1) {\n throw new GstException(\"gst1-java-core only supports GStreamer 1.x\");\n }\n if (requestedVersion.getMinor() < 8) {\n requestedVersion = new Version(1, 8);\n }\n if (!availableVersion.checkSatisfies(requestedVersion)) {\n throw new GstException(String.format(\n \"The requested version of GStreamer is not available\\nRequested : %s\\nAvailable : %s\\n\",\n requestedVersion, availableVersion));\n }\n }\n\n //\n // Only do real init the first time through\n //\n if (INIT_COUNT.getAndIncrement() > 0) {\n if (CHECK_VERSIONS) {\n if (requestedVersion.getMinor() > minorVersion) {\n minorVersion = (int) requestedVersion.getMinor();\n }\n }\n return args;\n }\n \n NativeArgs argv = new NativeArgs(progname, args);\n \n Pointer[] error = {null};\n if (!GST_API.gst_init_check(argv.argcRef, argv.argvRef, error)) {\n INIT_COUNT.decrementAndGet();\n throw new GstException(extractError(error[0]));\n }\n \n LOG.fine(\"after gst_init, argc=\" + argv.argcRef.getValue());\n \n Version runningVersion = getVersion();\n if (runningVersion.getMajor() != 1) {\n LOG.warning(\"gst1-java-core only supports GStreamer 1.x\");\n }\n \n if (useDefaultContext) {\n mainContext = GMainContext.getDefaultContext();\n executorService = new MainContextExecutorService(mainContext);\n } else {\n mainContext = new GMainContext();\n executorService = Executors.newSingleThreadScheduledExecutor(threadFactory);\n }\n quit = new CountDownLatch(1);\n loadAllClasses();\n \n if (CHECK_VERSIONS) {\n minorVersion = requestedVersion.getMinor();\n }\n \n return argv.toStringArray();\n }\n\n /**\n * Clean up any resources created by GStreamer in\n * {@link #init(org.freedesktop.gstreamer.Version)}.\n *\n * It is normally not needed to call this function in a normal\n * application as the resources will automatically be freed when the program\n * terminates. This function is therefore mostly used by testsuites and\n * other memory profiling tools.\n *\n * After this call GStreamer (including this method) should not be used\n * anymore.\n */\n public static synchronized final void deinit() {\n //\n // Only perform real shutdown if called as many times as Gst.init() is\n //\n if (INIT_COUNT.decrementAndGet() > 0) {\n return;\n }\n // Perform any cleanup tasks\n for (Object task : shutdownTasks.toArray()) {\n ((Runnable) task).run();\n }\n\n // Stop any more tasks/timers from being scheduled\n executorService.shutdown();\n\n // Wake up the run thread.\n quit();\n\n // Wait for tasks to complete.\n try {\n if (!executorService.awaitTermination(100, TimeUnit.MILLISECONDS)) {\n // Force-kill everything\n executorService.shutdownNow();\n }\n } catch (InterruptedException ex) {\n }\n \n mainContext = null;\n System.gc(); // Make sure any dangling objects are unreffed before calling deinit().\n GST_API.gst_deinit();\n }\n\n /**\n * Adds a task to be called when {@link Gst#deinit} is called.\n * \n * This is used internally, and is not recommended for other uses.\n *\n * @param task the task to execute.\n */\n static void addStaticShutdownTask(Runnable task) {\n shutdownTasks.add(task);\n }\n\n /**\n * Instructs gstreamer-java to use the default main context.\n * \n * This may be useful if integration with the GTK main loop is desirable, as\n * all {@link Bus} signals and timers will be executed in the context of the\n * GTK main loop.\n * \n * For the majority of programs though, it is better to wrap the individual\n * listeners in a proxy which executes the listener in the appropriate\n * context.\n *\n * @param useDefault if true, use the default glib main context.\n */\n public static void setUseDefaultContext(boolean useDefault) {\n useDefaultContext = useDefault;\n }\n\n /**\n * Checks that the version of GStreamer requested in init() satisfies the\n * given version or throws an exception.\n *\n * @param major major version, only 1 is supported\n * @param minor minor version required\n * @throws GstException if the requested version support was not requested\n */\n public static void checkVersion(int major, int minor) {\n if (CHECK_VERSIONS && (major != 1 || minor > minorVersion)) {\n throw new GstException(\"Not supported by requested GStreamer version\");\n }\n }\n\n /**\n * Tests that the version of GStreamer requested in init() satisfies the\n * given version.\n *\n * @param major major version, only 1 is supported\n * @param minor minor version required\n * @return boolean whether the version requirement can be satisfied\n */\n public static boolean testVersion(int major, int minor) {\n if (CHECK_VERSIONS && (major != 1 || minor > minorVersion)) {\n return false;\n }\n return true;\n }\n\n // Make the gstreamer executor threads daemon, so they don't stop the main \n // program from exiting\n private static final ThreadFactory threadFactory = new ThreadFactory() {\n private final AtomicInteger counter = new AtomicInteger(0);\n\n @Override\n public Thread newThread(Runnable task) {\n final String name = \"gstreamer service thread \" + counter.incrementAndGet();\n Thread t = new Thread(task, name);\n t.setDaemon(true);\n t.setPriority(Thread.NORM_PRIORITY);\n return t;\n }\n };\n \n private static synchronized void loadAllClasses() {\n Stream.of(new GLib.Types(),\n new Types(),\n new Event.Types(),\n new Message.Types(),\n new Query.Types(),\n new Controllers(),\n new Elements(),\n new WebRTC.Types(),\n new Video.Types())\n .flatMap(NativeObject.TypeProvider::types)\n .forEachOrdered(GstTypes::register);\n if (!DISABLE_EXTERNAL) {\n try {\n ServiceLoader \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstObject.html\n * \n * GstObject provides a root for the object hierarchy tree filed in by the\n * GStreamer library. It is currently a thin wrapper on top of {@link GObject}.\n * It is an abstract class that is not very usable on its own.\n *\n */\npublic class GstObject extends GObject {\n\n private static Logger LOG = Logger.getLogger(GstObject.class.getName());\n\n private final Handle handle;\n\n /**\n * Wraps an underlying C GstObject with a Java proxy\n *\n * @param init Initialization data\n */\n protected GstObject(Initializer init) {\n this(new Handle(init.ptr.as(GstObjectPtr.class, GstObjectPtr::new), init.ownsHandle), init.needRef);\n }\n\n protected GstObject(Handle handle, boolean needRef) {\n super(handle, needRef);\n this.handle = handle;\n }\n\n /**\n * Set the value of a GstObject property from a String representation.\n * \n * The data value is deserialized using \n * The data value is serialized using \n * If this function fails, it is most likely the application developers\n * fault. Most probably the control sources are not setup correctly.\n *\n * @param timestamp the time that should be processed\n * @return true if the controller values have been applied to the object\n * properties\n */\n public boolean syncValues(long timestamp) {\n return GSTOBJECT_API.gst_object_sync_values(handle.getPointer(), timestamp);\n }\n\n /**\n * Check if this object has active controlled properties.\n *\n * @return TRUE if the object has active controlled properties\n */\n public boolean hasActiveControlBindings() {\n return GSTOBJECT_API.gst_object_has_active_control_bindings(handle.getPointer());\n }\n\n /**\n * This function is used to disable all controlled properties of the object\n * for some time, i.e. {@link #syncValues(long) } will do nothing.\n *\n * @param disabled whether to disable the controllers or not\n */\n public void setControlBindingsDisabled(boolean disabled) {\n GSTOBJECT_API.gst_object_set_control_bindings_disabled(handle.getPointer(), disabled);\n }\n\n /**\n * This function is used to disable the control bindings on a property for\n * some time, i.e. {@link #syncValues(long) } will do nothing for the\n * property.\n *\n * @param propertyName property to disable\n * @param disabled whether to disable the controller or not\n */\n public void setControlBindingDisabled(String propertyName, boolean disabled) {\n GSTOBJECT_API.gst_object_set_control_binding_disabled(handle.getPointer(), propertyName, disabled);\n }\n\n /**\n * Attach a {@link ControlBinding } to this object. If there was already a\n * binding for this property it will be replaced.\n *\n * @param binding the ControlBinding that should be used\n * @throws IllegalStateException if the binding has not been setup for this\n * object\n */\n public void addControlBinding(ControlBinding binding) {\n GstControlBindingPtr bindingPtr = Natives.getPointer(binding)\n .as(GstControlBindingPtr.class, GstControlBindingPtr::new);\n boolean ok = GSTOBJECT_API.gst_object_add_control_binding(handle.getPointer(), bindingPtr);\n if (!ok) {\n throw new IllegalStateException();\n }\n }\n\n /**\n * Gets the corresponding {@link ControlBinding} for the property.\n *\n * @param propertyName name of the property\n * @return control binding for the property or NULL if the property is not\n * controlled\n */\n public ControlBinding getControlBinding(String propertyName) {\n GstControlBindingPtr ptr = GSTOBJECT_API.gst_object_get_control_binding(\n handle.getPointer(), propertyName);\n return ptr == null ? null : Natives.callerOwnsReturn(ptr, ControlBinding.class);\n }\n\n /**\n * Removes the corresponding {@link ControlBinding }.\n *\n * @param binding the binding to remove\n * @return true if the binding could be removed\n */\n public boolean removeControlBinding(ControlBinding binding) {\n GstControlBindingPtr bindingPtr = Natives.getPointer(binding)\n .as(GstControlBindingPtr.class, GstControlBindingPtr::new);\n return GSTOBJECT_API.gst_object_remove_control_binding(handle.getPointer(), bindingPtr);\n }\n\n @Override\n public String toString() {\n return String.format(\"%s: [%s]\", getClass().getSimpleName(), getName());\n }\n// protected static Initializer initializer(Pointer ptr) {\n// return initializer(ptr, true, true);\n// }\n// \n// protected static Initializer initializer(Pointer ptr, boolean needRef) {\n// return initializer(ptr, needRef, true);\n// }\n\n protected static class Handle extends GObject.Handle {\n\n public Handle(GstObjectPtr ptr, boolean ownsHandle) {\n super(ptr, ownsHandle);\n }\n\n @Override\n protected void ref() {\n GSTOBJECT_API.gst_object_ref(getPointer());\n }\n\n @Override\n protected void sink() {\n GSTOBJECT_API.gst_object_ref_sink(getPointer());\n }\n\n @Override\n protected void unref() {\n GSTOBJECT_API.gst_object_unref(getPointer());\n }\n\n @Override\n protected GstObjectPtr getPointer() {\n return (GstObjectPtr) super.getPointer();\n }\n\n }\n\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/Meta.java",
"content": "/*\n * Copyright (c) 2020 Neil C Smith\n *\n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under\n * the terms of the GNU Lesser General Public License version 3 only, as\n * published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License\n * version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * version 3 along with this work. If not, see \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/documentation/gstreamer/gstmeta.html\n * \n */\npublic class Meta extends NativeObject {\n\n /**\n * Create Meta from Initializer.\n *\n * @param init initializer.\n */\n protected Meta(Initializer init) {\n this(new Handle(init.ptr.as(GstMetaPtr.class, GstMetaPtr::new),\n init.ownsHandle));\n }\n\n /**\n * Create Meta from Handle.\n *\n * @param handle native object handle.\n */\n protected Meta(Handle handle) {\n super(handle);\n }\n\n @Override\n public String toString() {\n GstMetaPtr pointer = (GstMetaPtr)this.getPointer();\n return \"[meta : gType=\" + pointer.getGType() + \"]\";\n }\n\n /**\n * NativeObject.Handle implementation.\n */\n protected static class Handle extends NativeObject.Handle {\n\n /**\n * Create Handle.\n *\n * @param ptr pointer to underlying native GstMeta.\n * @param ownsHandle\n */\n public Handle(GstMetaPtr ptr, boolean ownsHandle) {\n super(ptr, ownsHandle);\n }\n\n @Override\n protected void disposeNativeHandle(GPointer ptr) {\n }\n\n }\n\n /**\n * API for Meta subclass. Used for querying from Buffer.\n * \n * The relevant API will usually be available as a public static final field\n * on the implementation class.\n * \n * The API type reflects two distinct types (api and implementation) used in\n * the underlying GStreamer GstMetaInfo.\n * \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/documentation/gstreamer/gstmeta.html#GstMetaInfo\n * \n *\n * @param \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/gstreamer-GstMiniObject.html\n * \n * MiniObject is a simple structure that can be used to implement refcounted\n * types.\n */\npublic abstract class MiniObject extends RefCountedObject {\n\n /**\n * Creates a new instance of MiniObject\n */\n protected MiniObject(Initializer init) {\n this(new Handle(init.ptr.as(GstMiniObjectPtr.class, GstMiniObjectPtr::new),\n init.ownsHandle), init.needRef);\n }\n \n protected MiniObject(Handle handle, boolean needRef) {\n super(handle, needRef);\n }\n\n /**\n * If mini_object has the LOCKABLE flag set, check if the current EXCLUSIVE\n * lock on object is the only one, this means that changes to the object\n * will not be visible to any other object.\n *\n * \n * \n * \n * The result is cast to subclass.\n *\n * @return a writable version (possibly a duplicate) of this MiniObject.\n */\n protected \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstPad.html\n * \n * An {@link Element} is linked to other elements via \"pads\", which are extremely\n * light-weight generic link points. After two pads are retrieved from an\n * element with {@link Element#getPad}, the pads can be link with {@link #link}.\n * (For quick links, you can also use {@link Element#link}, which will make the\n * obvious link for you if it's straightforward.)\n * \n * Pads are typically created from a {@link PadTemplate} with\n * {@link #Pad(PadTemplate, String)}.\n * \n * Pads have {@link Caps} attached to it to describe the media type they are\n * capable of dealing with. {@link #queryCaps} and {@link #setCaps} are used to\n * manipulate the caps of the pads. Pads created from a pad template cannot set\n * capabilities that are incompatible with the pad template capabilities.\n * \n * Pads without pad templates can be created with gst_pad_new(), which takes a\n * direction and a name as an argument. If the name is NULL, then a guaranteed\n * unique name will be assigned to it.\n * \n * {@link #getParentElement} will retrieve the Element that owns the pad.\n * \n * An Element creating a pad will typically use the various\n * gst_pad_set_*_function() calls to register callbacks for various events on\n * the pads.\n * \n * GstElements will use gst_pad_push() and gst_pad_pull_range() to push out or\n * pull in a buffer.\n * \n * To send an Event on a pad, use {@link #sendEvent} and {@link #pushEvent}.\n *\n * @see PadTemplate\n * @see Element\n * @see Event\n */\npublic class Pad extends GstObject {\n\n public static final String GTYPE_NAME = \"GstPad\";\n\n private static final int EVENT_HAS_INFO_MASK = GstPadAPI.GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | GstPadAPI.GST_PAD_PROBE_TYPE_EVENT_UPSTREAM;\n private final Handle handle;\n\n /**\n * Creates a new instance of Pad\n */\n Pad(Initializer init) {\n this(new Handle(init.ptr.as(GstPadPtr.class, GstPadPtr::new), init.ownsHandle), init.needRef);\n }\n\n private Pad(Handle handle, boolean needRef) {\n super(handle, needRef);\n this.handle = handle;\n }\n\n /**\n * Creates a new pad with the given name in the given direction. If name is\n * null, a guaranteed unique name (across all pads) will be assigned.\n *\n * @param name The name of the new pad.\n * @param direction The direction of the new pad.\n */\n public Pad(String name, PadDirection direction) {\n this(Natives.initializer(GSTPAD_API.ptr_gst_pad_new(name, direction), false));\n }\n\n /**\n * Creates a new pad with the given name from the given template.\n *\n * If name is null, a guaranteed unique name (across all pads) will be\n * assigned.\n *\n * @param template The pad template to use.\n * @param name The name of the new pad.\n */\n public Pad(PadTemplate template, String name) {\n this(Natives.initializer(GSTPAD_API.ptr_gst_pad_new_from_template(template, name), false));\n }\n\n /**\n * Gets the capabilities this pad can produce or consume. Note that this\n * method doesn't necessarily return the caps set by sending a\n * gst_event_new_caps() - use {@link #getCurrentCaps() } for that instead.\n * queryCaps returns all possible caps a pad can operate with,\n * using the pad's CAPS query function, If the query fails, this function\n * will return filter, if not NULL, otherwise ANY.\n * \n * When called on sinkpads filter contains the caps that upstream could\n * produce in the order preferred by upstream. When called on srcpads filter\n * contains the caps accepted by downstream in the preferred order. filter\n * might be NULL but if it is not NULL the returned caps will be a subset of\n * filter .\n * \n * Note that this function does not return writable Caps.\n *\n * @param filter suggested Caps or null\n * @return a newly allocated copy of the {@link Caps} of this pad.\n */\n public Caps queryCaps(Caps filter) {\n return GSTPAD_API.gst_pad_query_caps(this, filter);\n }\n\n /**\n * Gets the capabilities of the allowed media types that can flow through\n * this pad and its peer.\n * \n * The allowed capabilities is calculated as the intersection of the results\n * of calling {@link #queryCaps} on this pad and its peer.\n * \n * MT safe.\n *\n * @return The allowed {@link Caps} of the pad link, or null if this pad has\n * no peer.\n */\n public Caps getAllowedCaps() {\n return GSTPAD_API.gst_pad_get_allowed_caps(this);\n }\n\n /**\n * Gets the capabilities currently configured on pad with the last\n * GST_EVENT_CAPS event.\n *\n * @return the negotiated #GstCaps or null if this pad has\n * no current caps\n *\n */\n public Caps getCurrentCaps() {\n return GSTPAD_API.gst_pad_get_current_caps(this);\n }\n\n /**\n * Get the peer of this pad.\n *\n * MT safe.\n *\n * @return The peer Pad of this Pad.\n */\n public Pad getPeer() {\n return GSTPAD_API.gst_pad_get_peer(this);\n }\n\n /**\n * Get the capabilities of the peer connected to this pad.\n * \n * When called on srcpads filter contains the caps that upstream could\n * produce in the order preferred by upstream. When called on sinkpads\n * filter contains the caps accepted by downstream in the preferred order.\n * filter might be NULL but if it is not NULL the returned caps will be a\n * subset of filter .\n *\n * @param filter Caps to filter by, or null\n * @return the {@link Caps} of the peer pad, or null if there is no peer\n * pad.\n */\n public Caps peerQueryCaps(Caps filter) {\n return GSTPAD_API.gst_pad_peer_query_caps(this, filter);\n }\n\n /**\n * Check if the pad accepts the given caps.\n *\n * @param caps a {@link Caps} to check on the pad.\n * @return true if the pad can accept the caps.\n */\n public boolean queryAcceptCaps(Caps caps) {\n return GSTPAD_API.gst_pad_query_accept_caps(this, caps);\n }\n\n /**\n * Check if the peer of this pad accepts the caps. If this pad has no peer,\n * this method returns true.\n *\n * @param caps {@link Caps} to check on the pad\n * @return true if the peer pad can accept the caps or this pad no peer.\n */\n public boolean peerQueryAcceptCaps(Caps caps) {\n return GSTPAD_API.gst_pad_peer_query_accept_caps(this, caps);\n }\n\n /**\n * Links this source pad and a sink pad.\n *\n * MT Safe.\n *\n * @param sink the sink Pad to link.\n * @throws PadLinkException if pads cannot be linked.\n */\n public void link(Pad sink) throws PadLinkException {\n PadLinkReturn result = GSTPAD_API.gst_pad_link(this, sink);\n if (result != PadLinkReturn.OK) {\n throw new PadLinkException(result);\n }\n }\n\n /**\n *\n * Unlinks the source pad from the sink pad. Will emit the \"unlinked\" signal\n * on both pads.\n *\n * MT safe.\n *\n * @param pad the sink Pad to unlink.\n * @return true if the pads were unlinked. This function returns false if\n * the pads were not linked together.\n */\n public boolean unlink(Pad pad) {\n return GSTPAD_API.gst_pad_unlink(this, pad);\n }\n\n /**\n * Check if this pad is linked to another pad or not.\n *\n * @return true if the pad is linked, else false.\n */\n public boolean isLinked() {\n return GSTPAD_API.gst_pad_is_linked(this);\n }\n\n /**\n * Get the direction of the pad. The direction of the pad is decided at\n * construction time so this function does not take the LOCK.\n *\n * @return The {@link PadDirection} of the pad.\n */\n public PadDirection getDirection() {\n return GSTPAD_API.gst_pad_get_direction(this);\n }\n\n /**\n * Get the parent of this pad, cast to an {@link Element}. If this pad has no\n * parent or its parent is not an element, returns null.\n *\n * @return The parent of the pad.\n */\n public Element getParentElement() {\n return GSTPAD_API.gst_pad_get_parent_element(this);\n }\n\n /**\n * Activates or deactivates the given pad. Normally called from within core\n * state change functions.\n * \n * If active is true, makes sure the pad is active. If it is already active,\n * either in push or pull mode, just return. Otherwise dispatches to the\n * pad's activate function to perform the actual activation.\n * \n * If not @active, checks the pad's current mode and calls\n * gst_pad_activate_push() or gst_pad_activate_pull(), as appropriate, with\n * a FALSE argument.\n *\n * @param active whether or not the pad should be active.\n * @return true if the operation was successful.\n */\n public boolean setActive(boolean active) {\n return GSTPAD_API.gst_pad_set_active(this, active);\n }\n\n /**\n * Checks if the pad is blocked or not. This function returns the last\n * requested state of the pad. It is not certain that the pad is actually\n * blocking at this point (see {@link #isBlocking}).\n *\n * @return true if the pad is blocked.\n */\n public boolean isBlocked() {\n return GSTPAD_API.gst_pad_is_blocked(this);\n }\n\n /**\n * Run a runnable under a blocked state\n *\n * @param callback The code to run when pad is blocked\n */\n public void block(final Runnable callback) {\n addEventProbe(new EVENT_PROBE() {\n public PadProbeReturn eventReceived(Pad pad, Event event) {\n callback.run();\n pad.removeCallback(EVENT_PROBE.class, this);\n return PadProbeReturn.REMOVE;\n }\n }, GstPadAPI.GST_PAD_PROBE_TYPE_IDLE);\n }\n\n /**\n * Checks if the pad is blocking or not. This is a guaranteed state of\n * whether the pad is actually blocking on a {@link Buffer} or an\n * {@link Event}.\n *\n * @return true if the pad is blocking.\n */\n public boolean isBlocking() {\n return GSTPAD_API.gst_pad_is_blocking(this);\n }\n\n /**\n * Add a listener for the \n * Probes are called in groups: First {@link PadProbeType#BLOCK} probes are\n * called, then others, then finally {@link PadProbeType#IDLE}. The only\n * exception here are IDLE probes that are called immediately if the pad is\n * already idle while calling addProbe(). In each of the groups, probes are\n * called in the order in which they were added.\n *\n * @param mask set of mask flags for probe - common options are fields of\n * {@link PadProbeType}\n * @param callback callback that will be called with notifications of the\n * pad state\n */\n public void addProbe(final Set \n * Probes are called in groups: First {@link PadProbeType#BLOCK} probes are\n * called, then others, then finally {@link PadProbeType#IDLE}. The only\n * exception here are IDLE probes that are called immediately if the pad is\n * already idle while calling addProbe(). In each of the groups, probes are\n * called in the order in which they were added.\n *\n * @param mask mask flag for probe\n * @param callback callback that will be called with notifications of the\n * pad state\n */\n public void addProbe(PadProbeType mask, PROBE callback) {\n addProbe(mask.intValue(), callback);\n }\n \n synchronized void addProbe(int mask, PROBE callback) {\n final GstPadAPI.PadProbeCallback probe = new GstPadAPI.PadProbeCallback() {\n @Override\n public PadProbeReturn callback(Pad pad, GstPadProbeInfo probeInfo, Pointer user_data) {\n PadProbeInfo info = new PadProbeInfo(probeInfo);\n PadProbeReturn ret = callback.probeCallback(pad, info);\n info.invalidate();\n if (ret == PadProbeReturn.REMOVE) {\n // don't want handle to try and remove in GCallback::disconnect\n // @TODO move to Map \n * This function can be used by applications to send events in the pipeline.\n *\n * \n * If this pad is a source pad, event should be an upstream event.\n * If this pad is a sink pad, event should be a downstream event.\n * \n * For example, you would not send a {@link EventType#EOS} on a src pad; EOS\n * events only propagate downstream.\n *\n * \n * Furthermore, some downstream events have to be serialized with data flow,\n * like EOS, while some can travel out-of-band, like\n * {@link EventType#FLUSH_START}. If the event needs to be serialized with\n * data flow, this function will take the pad's stream lock while calling\n * its event function.\n *\n * @param event the event to send.\n * @return true if the event was handled.\n */\n public boolean sendEvent(Event event) {\n return GSTPAD_API.gst_pad_send_event(this, event);\n }\n\n /**\n * Sends the event to the peer of this pad.\n *\n * \n * This function is mainly used by elements to send events to their peer\n * elements.\n *\n * @param event the event to send\n * @return true if the event was handled\n */\n public boolean pushEvent(Event event) {\n return GSTPAD_API.gst_pad_push_event(this, event);\n }\n\n /**\n * Chain a buffer to pad.\n * \n * The function returns {@link FlowReturn#FLUSHING} if the\n * pad was flushing.\n * \n * If the caps on buffer are different from the current caps on pad, this\n * function will call any function installed on pad (see\n * gst_pad_set_setcaps_function()). If the new caps are not acceptable for\n * pad, this function returns\n * {@link FlowReturn#NOT_NEGOTIATED}.\n * \n * The function proceeds calling the chain function installed on pad and the\n * return value of that function is returned to the caller.\n * {@link FlowReturn#NOT_SUPPORTED} is returned if pad has no\n * chain function.\n * \n * In all cases, success or failure, the caller loses its reference to\n * buffer after calling this function.\n *\n * @param buffer the Buffer, returns {@link FlowReturn#ERROR}\n * if NULL.\n * @return a org.gstreamer.FlowReturn\n */\n public FlowReturn chain(Buffer buffer) {\n return GSTPAD_API.gst_pad_chain(this, buffer);\n }\n\n /**\n * When pad is flushing this function returns\n * {@link FlowReturn#FLUSHING} immediately.\n * \n * Calls the getRange function of pad, see GstPadGetRangeFunction for a\n * description of a getRange function. If pad has no getRange function\n * installed (see gst_pad_set_getrange_function()) this function returns\n * {@link FlowReturn#NOT_SUPPORTED}.\n * \n * This is a lowlevel function. Usualy {@link Pad#pullRange} is used.\n *\n * @param offset The start offset of the buffer\n * @param size The length of the buffer\n * @param buffer the Buffer, returns {@link FlowReturn#ERROR} if NULL.\n * @return a FlowReturn from the peer pad. When this function returns OK,\n * buffer will contain a valid Buffer.\n */\n public FlowReturn getRange(long offset, int size, Buffer[] buffer) {\n return GSTPAD_API.gst_pad_get_range(this, offset, size, buffer);\n }\n\n /**\n * Pulls a buffer from the peer pad.\n * \n * This function will first trigger the pad block signal if it was\n * installed.\n * \n * When pad is not linked {@link FlowReturn#NOT_LINKED} is returned else\n * this function returns the result of {@link Pad#getRange} on the peer pad.\n * See {@link Pad#getRange} for a list of return values and for the\n * semantics of the arguments of this function.\n * \n * buffer's caps must either be unset or the same as what is already\n * configured on pad. Renegotiation within a running pull-mode pipeline is\n * not supported.\n *\n * @param offset The start offset of the buffer\n * @param size The length of the buffer\n * @param buffer the Buffer, returns {@link FlowReturn#ERROR} if NULL.\n * @return a FlowReturn from the peer pad. When this function returns OK,\n * buffer will contain a valid Buffer. MT safe.\n */\n public FlowReturn pullRange(long offset, int size, Buffer[] buffer) {\n return GSTPAD_API.gst_pad_pull_range(this, offset, size, buffer);\n }\n\n /**\n * Pushes a buffer to the peer of pad . This function will call installed\n * block probes before triggering any installed data probes.\n * \n * The function proceeds calling gst_pad_chain() on the peer pad and returns\n * the value from that function. If pad has no peer, {@link FlowReturn#NOT_LINKED}\n * will be returned.\n * \n * In all cases, success or failure, the caller loses its reference to\n * buffer after calling this function.\n *\n * @param buffer the GstBuffer to push returns GST_FLOW_ERROR if not.\n * [transfer full]\n * @return a GstFlowReturn from the peer pad.\n *\n * MT safe.\n */\n public FlowReturn push(final Buffer buffer) {\n return GSTPAD_API.gst_pad_push(this, buffer);\n }\n\n /**\n * Gets the template for pad.\n *\n * @return the GstPadTemplate from which this pad was instantiated, or NULL\n * if this pad has no template.\n */\n public PadTemplate getTemplate() {\n return GSTPAD_API.gst_pad_get_pad_template(this);\n }\n\n /**\n * Check if the pad has caps set on it with a GST_EVENT_CAPS events\n *\n * @return true if the pad has caps set\n */\n public boolean hasCurrentCaps() {\n return GSTPAD_API.gst_pad_has_current_caps(this);\n }\n\n /**\n * Signal emitted when new this {@link Pad} is linked to another {@link Pad}\n *\n * @see #connect(LINKED)\n * @see #disconnect(LINKED)\n */\n public static interface LINKED {\n\n /**\n * Called when a {@link Pad} is linked to another Pad.\n *\n * @param pad the pad that emitted the signal.\n * @param peer the peer pad that has been connected.\n */\n public void linked(Pad pad, Pad peer);\n }\n\n /**\n * Signal emitted when new this {@link Pad} is disconnected from a peer\n * {@link Pad}\n *\n * @see #connect(UNLINKED)\n * @see #disconnect(UNLINKED)\n */\n public static interface UNLINKED {\n\n /**\n * Called when a {@link Pad} is unlinked from another Pad.\n *\n * @param pad the pad that emitted the signal.\n * @param peer the peer pad that has been connected.\n */\n public void unlinked(Pad pad, Pad peer);\n }\n\n /**\n * Callback used by\n * {@link #addProbe(java.util.EnumSet, org.freedesktop.gstreamer.Pad.PROBE)}\n */\n public static interface PROBE {\n\n /**\n * Callback used by\n * {@link #addProbe(java.util.EnumSet, org.freedesktop.gstreamer.Pad.PROBE)}.\n * Gets called to notify about the current blocking type.\n * \n * The PadProbeInfo and any Buffer, Event or Query referenced from\n * it, is only valid for the duration of the callback.\n *\n * @param pad Pad that is blocked\n * @param info PadProbeInfo with access to underlying data\n * @return PadProbeReturn value\n */\n public PadProbeReturn probeCallback(Pad pad, PadProbeInfo info);\n\n }\n\n /**\n * Probe for listening when an event passes through this Pad.\n *\n * @see #addEventProbe(EVENT_PROBE)\n * @see #removeEventProbe(EVENT_PROBE)\n */\n public static interface EVENT_PROBE {\n\n public PadProbeReturn eventReceived(Pad pad, Event event);\n \n }\n\n /**\n * Probe for listening when new data is available on the Pad.\n *\n * @see #addDataProbe(DATA_PROBE)\n * @see #removeDataProbe(DATA_PROBE)\n */\n public static interface DATA_PROBE {\n\n public PadProbeReturn dataReceived(Pad pad, Buffer buffer);\n \n }\n\n private static class Handle extends GstObject.Handle {\n\n private final Set \n * For convenience, the various flag combinations are provided as immutable\n * Sets.\n * \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/documentation/gstreamer/gstpad.html#GstPadProbeType\n */\npublic enum PadProbeType implements NativeFlags \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstPadTemplate.html\n * \n * Pad and PadTemplates have {@code Caps} attached to it to describe the media\n * type they are capable of dealing with. {@link #getCaps} is used to get the\n * caps of a PadTemplate. It is not possible to modify the caps of a PadTemplate\n * after creation.\n */\npublic class PadTemplate extends GstObject {\n\n public static final String GTYPE_NAME = \"GstPadTemplate\";\n\n /**\n * Creates a new proxy for PadTemplate.\n * \n * This is only for internal use.\n *\n * @param init internal initialization data.\n */\n PadTemplate(Initializer init) {\n super(init);\n }\n\n /**\n * Creates a new pad template with a name according to the given template,\n * with the given arguments and {@link PadPresence#ALWAYS }\n *\n * @param nameTemplate the name template.\n * @param direction the direction of the template.\n * @param caps a {@code Caps} set for the template.\n */\n public PadTemplate(String nameTemplate, PadDirection direction, Caps caps) {\n this(Natives.initializer(GSTPADTEMPLATE_API.ptr_gst_pad_template_new(nameTemplate, direction, PadPresence.ALWAYS, caps)));\n }\n\n /**\n * Creates a new pad template with a name according to the given template\n * and with the given arguments.\n *\n * @param nameTemplate the name template.\n * @param direction the direction of the template.\n * @param presence the presence of the pad, which controls the lifetime.\n * @param caps a {@code Caps} set for the template.\n */\n public PadTemplate(String nameTemplate, PadDirection direction, PadPresence presence, Caps caps) {\n this(Natives.initializer(GSTPADTEMPLATE_API.ptr_gst_pad_template_new(nameTemplate, direction, presence, caps)));\n }\n\n /**\n * Gets the {@link Caps} set on this {@code PadTemplate}\n *\n * @return the media type on this template.\n */\n public Caps getCaps() {\n return GSTPADTEMPLATE_API.gst_pad_template_get_caps(this);\n }\n\n /**\n * Gets the name of this template\n *\n * @return the name of this template\n */\n public String getTemplateName() {\n return get(\"name-template\").toString();\n }\n\n /**\n * Gets the direction of this template\n *\n * @return {@link PadDirection}\n */\n public PadDirection getDirection() {\n Object d = get(\"direction\");\n if (d instanceof Number) {\n return PadDirection.values()[((Number) d).intValue()];\n }\n return null;\n }\n\n /**\n * Gets presence of this template\n *\n * @return {@link PadPresence}\n */\n public PadPresence getPresence() {\n Object p = get(\"presence\");\n if (p instanceof Number) {\n return PadPresence.values()[((Number) p).intValue()];\n }\n return null;\n }\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/Pipeline.java",
"content": "/* \n * Copyright (c) 2021 Neil C Smith\n * Copyright (c) 2008 Wayne Meissner\n * Copyright (C) 2000 Erik Walthinsen \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstPipeline.html\n * \n * Elements are added and removed from the pipeline using the {@code Bin}\n * methods like {@link Bin#add add} and {@link Bin#remove remove}.\n * \n * Before changing the state of the Pipeline (see {@link Element}) a {@link Bus}\n * can be retrieved with {@link #getBus getBus}. This bus can then be used to\n * receive {@link Message}s from the elements in the pipeline.\n * \n * By default, a Pipeline will automatically flush the pending Bus messages when\n * going to the NULL state to ensure that no circular references exist when no\n * messages are read from the Bus. This behaviour can be changed with\n * {@link #setAutoFlushBus setAutoFlushBus}\n * \n * When the Pipeline performs the PAUSED to PLAYING state change it will select\n * a clock for the elements. The clock selection algorithm will by default\n * select a clock provided by an element that is most upstream (closest to the\n * source). For live pipelines (ones that return\n * {@link StateChangeReturn#NO_PREROLL} from the\n * {@link Element#setState setState} call) this will select the clock provided\n * by the live source. For normal pipelines this will select a clock provided by\n * the sinks (most likely the audio sink). If no element provides a clock, a\n * default SystemClock is used.\n *\n * \n * The clock selection can be controlled with the gst_pipeline_use_clock()\n * method, which will enforce a given clock on the pipeline. With\n * gst_pipeline_auto_clock() the default clock selection algorithm can be\n * restored.\n *\n * \n * A Pipeline maintains a stream time for the elements. The stream time is\n * defined as the difference between the current clock time and the base time.\n * When the pipeline goes to READY or a flushing seek is performed on it, the\n * stream time is reset to 0. When the pipeline is set from PLAYING to PAUSED,\n * the current clock time is sampled and used to configure the base time for the\n * elements when the pipeline is set to PLAYING again. This default behaviour\n * can be changed with the gst_pipeline_set_new_stream_time() method.\n *\n * When sending a flushing seek event to a GstPipeline (see {@link #seek seek}),\n * it will make sure that the pipeline is properly PAUSED and resumed as well as\n * set the new stream time to 0 when the seek succeeded.\n */\npublic class Pipeline extends Bin {\n\n public static final String GST_NAME = \"pipeline\";\n public static final String GTYPE_NAME = \"GstPipeline\";\n\n private static Logger LOG = Logger.getLogger(Pipeline.class.getName());\n \n private final Handle handle;\n\n protected Pipeline(Initializer init) {\n this(new Handle(init.ptr.as(GstObjectPtr.class, GstObjectPtr::new), init.ownsHandle), init.needRef);\n }\n \n Pipeline(Handle handle, boolean needRef) {\n super(handle, needRef);\n this.handle = handle;\n handle.busRef.set(GSTPIPELINE_API.gst_pipeline_get_bus(this));\n }\n\n /**\n * Creates a new instance of Pipeline with a unique name.\n */\n public Pipeline() {\n this(Natives.initializer(GSTPIPELINE_API.ptr_gst_pipeline_new(null), false));\n }\n\n /**\n * Creates a new instance of Pipeline with the given name.\n *\n * @param name The name used to identify this pipeline.\n */\n public Pipeline(String name) {\n this(initializer(name));\n }\n\n private static Initializer initializer(String name) {\n Pointer new_pipeline = GSTPIPELINE_API.ptr_gst_pipeline_new(name);\n return Natives.initializer(new_pipeline, false);\n }\n\n /**\n * Usually, when a pipeline goes from READY to NULL state, it automatically\n * flushes all pending messages on the bus, which is done for refcounting\n * purposes, to break circular references.\n * \n * This means that applications that update state using (async) bus messages\n * (e.g. do certain things when a pipeline goes from PAUSED to READY) might\n * not get to see messages when the pipeline is shut down, because they\n * might be flushed before they can be dispatched in the main thread. This\n * behaviour can be disabled using this function.\n * \n * It is important that all messages on the bus are handled when the\n * automatic flushing is disabled else memory leaks will be introduced.\n * \n * MT safe.\n *\n * @param flush whether or not to automatically flush the bus when the\n * pipeline goes from READY to NULL state\n */\n public void setAutoFlushBus(boolean flush) {\n GSTPIPELINE_API.gst_pipeline_set_auto_flush_bus(this, flush);\n }\n\n /**\n * Checks if the pipeline will automatically flush messages when going to\n * the NULL state.\n * \n * MT safe.\n *\n * @return true if the pipeline automatically flushes messages.\n */\n public boolean getAutoFlushBus() {\n return GSTPIPELINE_API.gst_pipeline_get_auto_flush_bus(this);\n }\n\n /**\n * Set the clock for pipeline. The clock will be distributed to all the\n * elements managed by the pipeline.\n * \n * MT safe\n *\n * @param clock The {@link Clock} to use\n * @return true if the clock could be set on the pipeline, false if some\n * element did not accept the clock.\n *\n */\n public boolean setClock(Clock clock) {\n return GSTPIPELINE_API.gst_pipeline_set_clock(this, clock);\n }\n\n /**\n * Return the current {@link Clock} used by the pipeline.\n *\n * @return The {@link Clock} currently in use.\n */\n @Override\n public Clock getClock() {\n return GSTPIPELINE_API.gst_pipeline_get_clock(this);\n }\n\n /**\n * Force the Pipeline to use the a specific clock. The pipeline will always\n * use the given clock even if new clock providers are added to this\n * pipeline.\n * \n * MT safe\n *\n * @param clock The {@link Clock} to use. If clock is null, all clocking is\n * disabled, and the pipeline will run as fast as possible.\n *\n */\n public void useClock(Clock clock) {\n GSTPIPELINE_API.gst_pipeline_use_clock(this, clock);\n }\n\n /**\n * Gets the {@link Bus} this pipeline uses for messages.\n *\n * @return The {@link Bus} that this pipeline uses.\n */\n @Override\n public Bus getBus() {\n return handle.busRef.get();\n }\n\n /**\n * Sets the position in the media stream to time in nanoseconds.\n * \n * Prefer use of\n * {@link Element#seekSimple(org.freedesktop.gstreamer.Format, java.util.Set, long)}.\n *\n * @param time The time to change the position to.\n * @return true if seek is successful\n */\n // @TODO move seek and query methods on to element?\n public boolean seek(long time) {\n return seek(time, TimeUnit.NANOSECONDS);\n }\n\n /**\n * Sets the current position in the media stream.\n * \n * Prefer use of\n * {@link Element#seekSimple(org.freedesktop.gstreamer.Format, java.util.Set, long)}.\n *\n * @param time the time to change the position to.\n * @param unit the {@code TimeUnit} the time is expressed in.\n * @return true if seek is successful\n */\n public boolean seek(long time, TimeUnit unit) {\n return seek(1.0, Format.TIME, EnumSet.of(SeekFlags.FLUSH, SeekFlags.KEY_UNIT),\n SeekType.SET, TimeUnit.NANOSECONDS.convert(time, unit),\n SeekType.NONE, -1);\n }\n\n /**\n * Seeks to a new position in the media stream.\n *\n * \n * The start and stop values are expressed in format.\n * \n * A rate of 1.0 means normal playback rate, 2.0 means double speed.\n * Negative values means backwards playback. A value of 0.0 for the rate is\n * not allowed and should be accomplished instead by PAUSING the pipeline.\n * \n * A pipeline has a default playback segment configured with a start\n * position of 0, a stop position of -1 and a rate of 1.0. The currently\n * configured playback segment can be queried with #GST_QUERY_SEGMENT.\n * \n * startType and stopType specify how to adjust the currently configured\n * start and stop fields in segment. Adjustments can be made relative or\n * absolute to the last configured values. A type of {@link SeekType#NONE}\n * means that the position should not be updated.\n * \n * When the rate is positive and start has been updated, playback will start\n * from the newly configured start position.\n * \n * For negative rates, playback will start from the newly configured stop\n * position (if any). If the stop position if updated, it must be different\n * from -1 for negative rates.\n * \n * It is not possible to seek relative to the current playback position, to\n * do this, PAUSE the pipeline, query the current playback position with\n * {@link org.gstreamer.Pipeline#queryPosition queryPosition} and update the\n * playback segment current position with a {@link SeekType#SET} to the\n * desired position.\n *\n * @param rate the new playback rate\n * @param format the format of the seek values\n * @param seekFlags the seek flags\n * @param startType the type and flags for the new start position\n * @param start the value of the new start position\n * @param stopType the type and flags for the new stop position\n * @param stop the value of the new stop position\n * @return true if seek is successful\n */\n // for compatibility\n public boolean seek(double rate, Format format, EnumSet \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstPlugin.html\n * \n * GStreamer is extensible, so {@link Element} instances can be loaded at\n * runtime. A plugin system can provide one or more of the basic GStreamer\n * {@link PluginFeature} subclasses.\n * \n * A plugin should export a symbol \n * Once you have a handle to a #GstPlugin (e.g. from the #GstRegistryPool), you\n * can add any object that subclasses #GstPluginFeature.\n * \n * Use gst_plugin_find_feature() and gst_plugin_get_feature_list() to find\n * features in a plugin.\n * \n * Usually plugins are always automatically loaded so you don't need to call\n * {@link #loadByName} explicitly to bring it into memory. There are options to\n * statically link plugins to an app or even use GStreamer without a plugin\n * repository in which case {@link #loadByName} can be needed to bring the\n * plugin into memory.\n * \n * @see PluginFeature\n * @see ElementFactory\n */\npublic class Plugin extends GstObject {\n\n public static final String GTYPE_NAME = \"GstPlugin\";\n\n /**\n * Creates a new instance of GstElement\n *\n * @param init internal initialization data.\n */\n Plugin(Initializer init) {\n super(init);\n }\n\n /**\n * Load the named plugin.\n *\n * @param pluginName\n * @return A new Plugin reference if the plugin was loaded, else null.\n */\n public static Plugin loadByName(String pluginName) {\n return GSTPLUGIN_API.gst_plugin_load_by_name(pluginName);\n }\n\n /**\n * Get the short name of the plugin.\n *\n * @return the name of the plugin.\n */\n @Override\n public String getName() {\n return GSTPLUGIN_API.gst_plugin_get_name(this);\n }\n\n /**\n * Get the long descriptive name of the plugin.\n *\n * @return The long name of the plugin.\n */\n public String getDescription() {\n return GSTPLUGIN_API.gst_plugin_get_description(this);\n }\n\n /**\n * Get the filename of the plugin.\n *\n * @return The filename of the plugin.\n */\n public String getFilename() {\n return GSTPLUGIN_API.gst_plugin_get_filename(this);\n }\n\n /**\n * Get the version of the plugin.\n *\n * @return The version of the plugin.\n */\n public String getVersion() {\n return GSTPLUGIN_API.gst_plugin_get_version(this);\n }\n\n /**\n * Get the license of the plugin.\n *\n * @return The license of the plugin.\n */\n public String getLicense() {\n return GSTPLUGIN_API.gst_plugin_get_license(this);\n }\n\n /**\n * Get the source module the plugin belongs to.\n *\n * @return The source of the plugin.\n */\n public String getSource() {\n return GSTPLUGIN_API.gst_plugin_get_source(this);\n }\n\n /**\n * Get the package the plugin belongs to.\n *\n * @return The package of the plugin.\n */\n public String getPackage() {\n return GSTPLUGIN_API.gst_plugin_get_package(this);\n }\n\n /**\n * Get the URL where the plugin comes from.\n *\n * @return The origin of the plugin.\n */\n public String getOrigin() {\n return GSTPLUGIN_API.gst_plugin_get_origin(this);\n }\n\n /**\n * Get the release date (and possibly time) in form of a string, if\n * available.\n *\n * For normal GStreamer plugin releases this will usually just be a date in\n * the form of \"YYYY-MM-DD\", while pre-releases and builds from git may\n * contain a time component after the date as well, in which case the string\n * will be formatted like \"YYYY-MM-DDTHH:MMZ\" (e.g.\n * \"2012-04-30T09:30Z\").Test\n */\n public String getReleaseDateString() {\n return GSTPLUGIN_API.gst_plugin_get_release_date_string(this);\n }\n\n /**\n * Queries if the plugin is loaded into memory.\n *\n * @return true if it is loaded, false otherwise.\n */\n public boolean isLoaded() {\n return GSTPLUGIN_API.gst_plugin_is_loaded(this);\n }\n\n// /**\n// * Ensures this plugin is loaded.\n// *\n// * @return a potentially new Plugin reference.\n// */\n// public Plugin load() {\n// return GSTPLUGIN_API.gst_plugin_load(this);\n// }\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/PluginFeature.java",
"content": "/* \n * Copyright (C) 2019 Neil C Smith\n * Copyright (C) 2007 Wayne Meissner\n * Copyright (C) 1999,2000 Erik Walthinsen \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstPluginFeature.html\n * \n * This is a base class for anything that can be added to a Plugin.\n *\n * @see Plugin\n */\npublic class PluginFeature extends GstObject {\n\n public static final String GTYPE_NAME = \"GstPluginFeature\";\n\n /**\n * Element priority ranks. Defines the order in which the autoplugger (or\n * similar rank-picking mechanisms, such as e.g.\n * gst_element_make_from_uri()) will choose this element over an alternative\n * one with the same function.\n *\n * These constants serve as a rough guidance for defining the rank of a\n * GstPluginFeature. Any value is valid, including values bigger than\n * GST_RANK_PRIMARY .\n */\n public enum Rank implements NativeEnum \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstPromise.html\n * \n */\n@Gst.Since(minor = 14)\npublic class Promise extends MiniObject {\n\n public static final String GTYPE_NAME = \"GstPromise\";\n\n private GstCallback changeFunction;\n \n /**\n * Creates a new instance of Promise. This constructor is used internally.\n *\n * @param init internal initialization data.\n */\n Promise(final Initializer init) {\n super(init);\n }\n\n /**\n * Creates a new instance of promise\n */\n public Promise() {\n this(Natives.initializer(GSTPROMISE_API.ptr_gst_promise_new()));\n Gst.checkVersion(1, 14); // @TODO ideally this check would be before native call!\n }\n\n /**\n * Creates a new instance of promise with a callback attached.\n *\n * @param listener Listener to be called whenever the state of a\n * {@link Promise} is changed\n */\n public Promise(final PROMISE_CHANGE listener) {\n this(new GstCallback() {\n public void callback(Promise promise, Pointer userData) {\n listener.onChange(promise);\n }\n });\n }\n \n private Promise(GstCallback callback) {\n this(Natives.initializer(GSTPROMISE_API\n .ptr_gst_promise_new_with_change_func(callback, null, null)));\n this.changeFunction = callback;\n }\n\n /**\n * Wait for the promise to move out of the PENDING {@link PromiseResult}\n * state. If the promise is not in PENDING then it will immediately return.\n *\n * @return the {@link PromiseResult} of the promise.\n */\n public PromiseResult waitResult() {\n return GSTPROMISE_API.gst_promise_wait(this);\n }\n\n /**\n * Set a reply on the promise.\n *\n * Will wake up any waiters on the promise with the REPLIED\n * {@link PromiseResult} state. If the promise has already been interrupted\n * than the replied will not be visible to any waiters\n *\n * @param structure the {@link Structure} to reply the promise with, caller\n * should not use this structure afterward as it is invalidated through\n * {@link NativeObject#invalidate()}\n */\n public void reply(final Structure structure) {\n GSTPROMISE_API.gst_promise_reply(this, structure);\n }\n\n /**\n * Interrupt waiting for the result of the promise.\n *\n * Any waiters on the promise will receive the INTERRUPTED\n * {@link PromiseResult} state.\n */\n public void interrupt() {\n GSTPROMISE_API.gst_promise_interrupt(this);\n }\n\n /**\n * Expire a promise.\n *\n * Any waiters on the promise will received the EXPIRED\n * {@link PromiseResult} state.\n */\n public void expire() {\n GSTPROMISE_API.gst_promise_expire(this);\n }\n\n /**\n * Retrieve the reply set on the promise.\n *\n * The state of the promise must be in the REPLIED {@link PromiseResult}\n * state. The return structure is owned by the promise and thus cannot be\n * modified.\n *\n * @return the {@link Structure} set on the promise reply.\n */\n public Structure getReply() {\n return Structure.objectFor(GSTPROMISE_API.ptr_gst_promise_get_reply(this), false, false);\n }\n\n /**\n * Called whenever the state of the promise is changed from PENDING to any\n * other {@link PromiseResult}\n */\n public static interface PROMISE_CHANGE {\n\n /**\n * Called whenever the state of the promise is changed from PENDING to\n * any other {@link PromiseResult}\n *\n * @param promise the original promise that had the callback attached to\n */\n public void onChange(Promise promise);\n }\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/PromiseResult.java",
"content": "/*\n * Copyright (c) 2019 Neil C Smith\n * Copyright (c) 2018 Antonio Morales\n * \n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under the terms of the GNU\n * Lesser General Public License version 3 only, as published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without\n * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * Lesser General Public License version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License version 3 along with\n * this work. If not, see \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstRegistry.html\n * \n * One registry holds the metadata of a set of plugins.\n * All registries build the RegistryPool.\n * \n * Design:\n * \n * The Registry object is a list of plugins and some methods for dealing\n * with them. Plugins are matched 1-1 with a file on disk, and may or may\n * not be loaded at a given time. There may be multiple Registry objects,\n * but the \"default registry\" is the only object that has any meaning to the\n * core.\n * \n * The registry.xml file is actually a cache of plugin information. This is\n * unlike versions prior to 0.10, where the registry file was the primary source\n * of plugin information, and was created by the gst-register command.\n * \n * The primary source, at all times, of plugin information is each plugin file\n * itself. Thus, if an application wants information about a particular plugin,\n * or wants to search for a feature that satisfies given criteria, the primary\n * means of doing so is to load every plugin and look at the resulting\n * information that is gathered in the default registry. Clearly, this is a time\n * consuming process, so we cache information in the registry.xml file.\n * \n * On startup, plugins are searched for in the plugin search path. This path can\n * be set directly using the GST_PLUGIN_PATH environment variable. The registry\n * file is loaded from ~/.gstreamer-$GST_MAJORMINOR/registry-$ARCH.xml or the\n * file listed in the GST_REGISTRY environment variable. The only reason to change the\n * registry location is for testing.\n * \n * For each plugin that is found in the plugin search path, there could be 3\n * possibilities for cached information:\n * \n * In the first two cases, the plugin is loaded and the cache updated. In\n * addition to these cases, the cache may have entries for plugins that are not\n * relevant to the current process. These are marked as not available to the\n * current process. If the cache is updated for whatever reason, it is marked\n * dirty.\n * \n * A dirty cache is written out at the end of initialization. Each entry is\n * checked to make sure the information is minimally valid. If not, the entry is\n * simply dropped.\n * \n * \n * The \"cache\" and \"default registry\" are different concepts and can represent\n * different sets of plugins. For various reasons, at init time, the cache is\n * stored in the default registry, and plugins not relevant to the current\n * process are marked with the %GST_PLUGIN_FLAG_CACHED bit. These plugins are\n * removed at the end of intitialization.\n */\npublic class Registry extends GstObject {\n public static final String GTYPE_NAME = \"GstRegistry\";\n\n /** Creates a new instance of Registry */\n Registry(Initializer init) {\n super(init);\n }\n \n /**\n * Find a plugin in the registry.\n * \n * @param name The plugin name to find.\n * @return The plugin with the given name or null if the plugin was not found.\n */\n public Plugin findPlugin(String name) {\n return GSTREGISTRY_API.gst_registry_find_plugin(this, name);\n }\n /**\n * Add the plugin to the registry. The plugin-added signal will be emitted.\n *\n * @param plugin the {@link Plugin} to add\n * @return true on success.\n */\n public boolean addPlugin(Plugin plugin) {\n return GSTREGISTRY_API.gst_registry_add_plugin(this, plugin);\n }\n \n /**\n * Remove a plugin from the registry.\n * \n * @param plugin The plugin to remove.\n */\n public void removePlugin(Plugin plugin) {\n GSTREGISTRY_API.gst_registry_remove_plugin(this, plugin);\n }\n \n// /**\n// * Find the {@link PluginFeature} with the given name and type in the registry.\n// * \n// * @param name The name of the plugin feature to find.\n// * @param type The type of the plugin feature to find.\n// * @return The pluginfeature with the given name and type or null\n// * if the plugin was not found.\n// */\n// public PluginFeature findPluginFeature(String name, GType type) {\n// return GSTREGISTRY_API.gst_registry_find_feature(this, name, type);\n// }\n \n /**\n * Find a {@link PluginFeature} by name in the registry.\n *\n * @param name The name of the plugin feature to find.\n * @return The {@link PluginFeature} or null if not found.\n */\n public PluginFeature lookupFeature(String name) {\n return GSTREGISTRY_API.gst_registry_lookup_feature(this, name);\n }\n \n /**\n * Get a list of all plugins registered in the registry. \n *\n * @return a List of {@link Plugin}\n */\n public List \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gst-plugins-base-libs/html/gst-plugins-base-libs-GstSDPMessage.html\n */\npublic class SDPMessage extends NativeObject {\n public static final String GTYPE_NAME = \"GstSDPMessage\";\n\n /**\n * Internally used constructor. Do not use.\n *\n * @param init internal initialization data\n */\n SDPMessage(Initializer init) {\n this(new Handle(init.ptr, init.ownsHandle));\n }\n\n SDPMessage(Handle handle) {\n super(handle);\n }\n \n /**\n * Creates a new instance of SDPMessage\n */\n public SDPMessage() {\n this(initHandle());\n }\n \n /**\n * A SDP formatted string representation of SDPMessage.\n *\n * Used for offer/answer exchanges for real time communicationse\n *\n * @return the SDP string representation of SDPMessage.\n */\n public String toString() {\n return GSTSDPMESSAGE_API.gst_sdp_message_as_text(this);\n }\n\n /**\n * Takes a SDP string and parses it and fills in all fields for SDPMessage.\n *\n * Look at https://tools.ietf.org/html/rfc4566 for more information on SDP\n *\n * @param sdpString the sdp string\n */\n public void parseBuffer(String sdpString) {\n byte[] data = sdpString.getBytes(StandardCharsets.US_ASCII);\n int length = sdpString.length();\n GSTSDPMESSAGE_API.gst_sdp_message_parse_buffer(data, length, this);\n }\n\n// /**\n// * Creates a copy of this SDPMessage.\n// *\n// * @return a copy of SDPMessage.\n// */\n// SDPMessage copy(boolean shouldInvalidateOriginal) {\n// Pointer[] ptr = new Pointer[1];\n// GSTSDPMESSAGE_API.gst_sdp_message_copy(this, ptr);\n// if (shouldInvalidateOriginal) {\n// this.invalidate();\n// }\n// return new SDPMessage(initializer(ptr[0]));\n// }\n\n private static Handle initHandle() {\n Pointer[] ptr = new Pointer[1];\n GSTSDPMESSAGE_API.gst_sdp_message_new(ptr);\n return new Handle(new GPointer(ptr[0]), true);\n }\n\n private static final class Handle extends NativeObject.Handle {\n\n public Handle(GPointer ptr, boolean ownsHandle) {\n super(ptr, ownsHandle);\n }\n\n @Override\n protected void disposeNativeHandle(GPointer ptr) {\n GSTSDPMESSAGE_API.gst_sdp_message_free(ptr.getPointer());\n }\n \n }\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/SDPResult.java",
"content": "/*\n * Copyright (c) 2019 Neil C Smith\n * Copyright (c) 2018 Antonio Morales\n * \n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under the terms of the GNU\n * Lesser General Public License version 3 only, as published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without\n * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * Lesser General Public License version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License version 3 along with\n * this work. If not, see \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gst-plugins-base-libs/html/gst-plugins-base-libs-GstSDPMessage.html#GstSDPResult\n * \n * @see SDPMessage\n */\npublic enum SDPResult implements NativeEnum \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstSample.html\n *\n */\npublic class Sample extends MiniObject {\n\n public static final String GTYPE_NAME = \"GstSample\";\n\n Sample(Initializer init) {\n super(init);\n }\n\n /**\n * Get the {@link Caps} associated with sample, or NULL when there is no caps. \n * The caps remains valid as long as sample is valid.\n * If you need to hold on to the caps for longer than that, take a ref to the caps \n *\n * @return caps of sample or NULL when there is no caps.\n */\n public Caps getCaps() {\n return GSTSAMPLE_API.gst_sample_get_caps(this);\n }\n \n /**\n * Set the {@link Caps} associated with sample. \n * This sample must be writable.\n * \n * Since GStreamer 1.16\n * \n * @param caps\n */\n @Gst.Since(minor = 16)\n public void setCaps(Caps caps) {\n \tGst.checkVersion(1, 16);\n \tGSTSAMPLE_API.gst_sample_set_caps(this, caps);\n }\n\n /**\n * Get the {@link Buffer} associated with sample, or NULL when there is no\n * buffer.\n * The buffer remains valid as long as sample is valid.\n * If you need to hold on to it for longer than that, take a ref to the buffer.\n *\n * @return buffer of sample or NULL when there is no buffer.\n */\n public Buffer getBuffer() {\n return GSTSAMPLE_API.gst_sample_get_buffer(this);\n }\n \n /**\n * Set the {@link Buffer} associated with sample. \n * This sample must be writable.\n * \n * Since GStreamer 1.16\n * \n * @param buffer\n */\n @Gst.Since(minor = 16)\n public void setBuffer(Buffer buffer) {\n \tGst.checkVersion(1, 16);\n \tGSTSAMPLE_API.gst_sample_set_buffer(this, buffer);\n }\n \n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/Segment.java",
"content": "/*\n * Copyright (c) 2010 David Hoyt \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstElement.html#GstState\n * \n */\npublic enum State implements NativeEnum \n * Only {@link StateChangeReturn#FAILURE} is a real failure.\n * \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstElement.html#GstStateChangeReturn\n * \n */\npublic enum StateChangeReturn implements NativeEnum \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstStructure.html\n * \n * A Structure is a collection of key/value pairs. The keys are expressed as\n * GQuarks and the values can be of any GType.\n * \n * In addition to the key/value pairs, a Structure also has a name. The name\n * starts with a letter and can be followed by letters, numbers and any of\n * \"/-_.:\".\n * \n * Structure is used by various GStreamer subsystems to store information in a\n * flexible and extensible way.\n * \n * A Structure can be created with new {@link #Structure(String)} or\n * {@link #Structure(String, String, Object...)}, which both take a name and an\n * optional set of key/value pairs along with the types of the values.\n * \n * Field values can be changed with set{Integer,String}() etc functions.\n * \n * Field values can be retrieved with get{Integer,String}() etc functions.\n * \n * Fields can be removed with {@link #removeField} or {@link #removeFields}\n *\n * @see Caps\n * @see Event\n */\npublic class Structure extends NativeObject {\n \n public static final String GTYPE_NAME = \"GstStructure\";\n\n /**\n * Creates a new, empty #GstStructure with the given name.\n *\n * @param name The name of new structure.\n */\n public Structure(String name) {\n this(new Handle(new GPointer(GSTSTRUCTURE_API.ptr_gst_structure_new_empty(name)), true));\n }\n\n /**\n * Creates a new Structure with the given name. Parses the list of variable\n * arguments and sets fields to the values listed. Variable arguments should\n * be passed as field name, field type, and value.\n *\n * @param name The name of new structure.\n * @param firstFieldName The name of first field to set\n * @param data Additional arguments.\n */\n public Structure(String name, String firstFieldName, Object... data) {\n this(new Handle(new GPointer(GSTSTRUCTURE_API.ptr_gst_structure_new(name, firstFieldName, data)), true));\n }\n /**\n * Creates a new instance of Structure\n */\n Structure(Initializer init) {\n this(new Handle(init.ptr, init.ownsHandle));\n }\n \n private Structure(Handle handle) {\n super(handle);\n }\n\n public Structure copy() {\n return GSTSTRUCTURE_API.gst_structure_copy(this);\n }\n\n public boolean fixateNearestInteger(String field, Integer value) {\n return GSTSTRUCTURE_API.gst_structure_fixate_field_nearest_int(this, field, value);\n }\n /**\n * Get the value of the named field as a boolean. Throws\n * {@link InvalidFieldException} if the Structure does not contain the named\n * field or the named field is not a boolean.\n *\n * @param fieldName name of field\n * @return boolean value of the named field\n */\n public boolean getBoolean(String fieldName) {\n int[] val = {0};\n if (!GSTSTRUCTURE_API.gst_structure_get_boolean(this, fieldName, val)) {\n throw new InvalidFieldException(\"boolean\", fieldName);\n }\n return val[0] != 0;\n }\n\n /**\n * Get the value of the named field as a double. Throws\n * {@link InvalidFieldException} if the Structure does not contain the named\n * field or the named field is not a double.\n *\n * @param fieldName name of field\n * @return double value of the named field\n */\n public double getDouble(String fieldName) {\n double[] val = {0d};\n if (!GSTSTRUCTURE_API.gst_structure_get_double(this, fieldName, val)) {\n throw new InvalidFieldException(\"double\", fieldName);\n }\n return val[0];\n }\n\n /**\n * Extract the values of the named field as an array of doubles. If the\n * native GType of the field is a GValueArray then this method will return\n * an array of the contained values, assuming all contained values are of\n * G_TYPE_DOUBLE. Else if the field is of G_TYPE_DOUBLE a single value array\n * will be returned.\n * \n * This method will create a new array each time. If you are repeatedly\n * calling this method consider using\n * {@link #getDoubles(java.lang.String, double[])}.\n * \n * Throws {@link InvalidFieldException} if the field does not exist, or the\n * field values contained are not of type G_TYPE_DOUBLE.\n * \n * This method only currently supports lists of values inside a GValueArray\n * - other native list types will be supported in future.\n *\n * @param fieldName name of field\n * @return List of values from the named field\n */\n public double[] getDoubles(String fieldName) {\n return getDoubles(fieldName, null);\n }\n\n /**\n * Extract the values of the named field as an array of doubles. If the\n * native GType of the field is a GValueArray then this method will return\n * an array of the contained values, assuming all contained values are of\n * G_TYPE_DOUBLE. Else if the field is of G_TYPE_DOUBLE a single value array\n * will be returned.\n * \n * An array may be passed into this method to contain the result. A new\n * array will be created if the array is null or not of the correct length.\n * \n * Throws {@link InvalidFieldException} if the field does not exist, or the\n * field values contained are not of type G_TYPE_DOUBLE.\n * \n * This method only currently supports lists of values inside a GValueArray\n * - other native list types will be supported in future.\n *\n * @param fieldName name of field\n * @param array an array to hold values, or null\n * @return List of values from the named field\n */\n public double[] getDoubles(String fieldName, double[] array) {\n Object val = getValue(fieldName);\n if (val instanceof GValueAPI.GValueArray) {\n GValueAPI.GValueArray arr = (GValueAPI.GValueArray) val;\n int count = arr.getNValues();\n double[] values = array == null || array.length != count\n ? new double[count] : array;\n for (int i = 0; i < count; i++) {\n GValue gval = arr.nth(i);\n if (gval.checkHolds(GType.DOUBLE)) {\n values[i] = GValueAPI.GVALUE_API.g_value_get_double(gval);\n } else {\n throw new InvalidFieldException(\"doubles\", fieldName);\n }\n }\n return values;\n } else {\n if (Double.class.isInstance(val)) {\n double[] values = array == null || array.length != 1\n ? new double[1] : array;\n values[0] = ((Double) val);\n return values;\n } else {\n throw new InvalidFieldException(\"double\", fieldName);\n }\n }\n }\n\n /**\n * Get the number of fields in the {@link Structure}.\n *\n * @return the structure's filed number.\n */\n public int getFields() {\n return GSTSTRUCTURE_API.gst_structure_n_fields(this);\n }\n\n\n /**\n * Gets FOURCC field int representation\n *\n * @param fieldName The name of the field.\n * @return FOURCC field as a 4 byte integer\n */\n public int getFourcc(String fieldName) {\n int[] val = {0};\n if (!GSTSTRUCTURE_API.gst_structure_get_fourcc(this, fieldName, val)) {\n throw new InvalidFieldException(\"FOURCC\", fieldName);\n }\n return val[0];\n }\n\n /**\n * Gets FOURCC field String representation\n *\n * @param fieldName The name of the field.\n * @return FOURCC field as a String\n */\n public String getFourccString(String fieldName) {\n int f = getFourcc(fieldName);\n byte[] b = {(byte) ((f >> 0) & 0xff), (byte) ((f >> 8) & 0xff),\n (byte) ((f >> 16) & 0xff), (byte) ((f >> 24) & 0xff)};\n return new String(b);\n }\n \n /**\n * Get the value of the named field as a Fraction. Throws\n * {@link InvalidFieldException} if the Structure does not contain the named\n * field or the named field is not a Fraction.\n *\n * @param fieldName name of field\n * @return boolean value of the named field\n */\n public Fraction getFraction(String fieldName) {\n int[] numerator = {0};\n int[] denominator = {0};\n if (!GSTSTRUCTURE_API.gst_structure_get_fraction(this, fieldName, numerator, denominator)) {\n throw new InvalidFieldException(\"fraction\", fieldName);\n }\n return new Fraction(numerator[0], denominator[0]);\n }\n /**\n * Get the value of the named field as an int. Throws\n * {@link InvalidFieldException} if the Structure does not contain the named\n * field or the named field is not an integer.\n *\n * @param fieldName name of field\n * @return int value of the named field\n */\n public int getInteger(String fieldName) {\n int[] val = {0};\n if (!GSTSTRUCTURE_API.gst_structure_get_int(this, fieldName, val)) {\n throw new InvalidFieldException(\"integer\", fieldName);\n }\n return val[0];\n }\n\n /**\n * Extract the values of the named field as an array of integers. If the\n * native GType of the field is a GValueArray then this method will return\n * an array of the contained values, assuming all contained values are of\n * G_TYPE_INT. Else if the field is of G_TYPE_INT a single value array will\n * be returned.\n * \n * This method will create a new array each time. If you are repeatedly\n * calling this method consider using\n * {@link #getIntegers(java.lang.String, int[])}.\n * \n * Throws {@link InvalidFieldException} if the field does not exist, or the\n * field values contained are not of type G_TYPE_INT.\n * \n * This method only currently supports lists of values inside a GValueArray\n * - other native list types will be supported in future.\n *\n * @param fieldName name of field\n * @return List of values from the named field\n */\n public int[] getIntegers(String fieldName) {\n return getIntegers(fieldName, null);\n }\n /**\n * Extract the values of the named field as an array of integers. If the\n * native GType of the field is a GValueArray then this method will return\n * an array of the contained values, assuming all contained values are of\n * G_TYPE_INT. Else if the field is of G_TYPE_INT a single value array will\n * be returned.\n * \n * An array may be passed into this method to contain the result. A new\n * array will be created if the array is null or not of the correct length.\n * \n * Throws {@link InvalidFieldException} if the field does not exist, or the\n * field values contained are not of type G_TYPE_INT.\n * \n * This method only currently supports lists of values inside a GValueArray\n * - other native list types will be supported in future.\n *\n * @param fieldName name of field\n * @param array an array to hold values, or null\n * @return List of values from the named field\n */\n public int[] getIntegers(String fieldName, int[] array) {\n Object val = getValue(fieldName);\n if (val instanceof GValueAPI.GValueArray) {\n GValueAPI.GValueArray arr = (GValueAPI.GValueArray) val;\n int count = arr.getNValues();\n int[] values = array == null || array.length != count\n ? new int[count] : array;\n for (int i = 0; i < count; i++) {\n GValue gval = arr.nth(i);\n if (gval.checkHolds(GType.INT)) {\n values[i] = GValueAPI.GVALUE_API.g_value_get_int(gval);\n } else {\n throw new InvalidFieldException(\"integers\", fieldName);\n }\n }\n return values;\n } else {\n if (Integer.class.isInstance(val)) {\n int[] values = array == null || array.length != 1\n ? new int[1] : array;\n values[0] = ((Integer) val);\n return values;\n } else {\n throw new InvalidFieldException(\"integer\", fieldName);\n }\n }\n }\n\n /**\n * Sets the name of the structure to the given name.\n *\n * The name must not be empty, must start with a letter and can be followed\n * by letters, numbers and any of \"/-_.:\".\n *\n * @param name The new name of the structure.\n */\n public void setName(String name) {\n GSTSTRUCTURE_API.gst_structure_set_name(this, name);\n }\n\n /**\n * Get the name of @structure as a string.\n *\n * @return The name of the structure.\n */\n public String getName() {\n return GSTSTRUCTURE_API.gst_structure_get_name(this);\n }\n \n /**\n * Get the @structure's ith field name as a string.\n *\n * @param i the requested filed number\n * @return The name of the structure.\n */\n public String getName(int i) {\n return GSTSTRUCTURE_API.gst_structure_nth_field_name(this, i);\n }\n\n /**\n * Get the value of the named field as a Range. Throws\n * {@link InvalidFieldException} if the Structure does not contain the named\n * field.\n *\n * @param fieldName name of field\n * @return Range value of the named field\n */\n public Range getRange(String fieldName) {\n GValue val = GSTSTRUCTURE_API.gst_structure_get_value(this, fieldName);\n if (val == null) {\n throw new InvalidFieldException(\"Range\", fieldName);\n }\n return new Range(val);\n }\n /**\n * Get the value of the named field as a String.\n *\n * @param fieldName name of field\n * @return String value of the named field\n */\n public String getString(String fieldName) {\n return GSTSTRUCTURE_API.gst_structure_get_string(this, fieldName);\n }\n \n /**\n * Get the value of the named field. Throws {@link InvalidFieldException} if\n * the Structure does not contain the named field.\n *\n * @param fieldName name of field\n * @return Object representation of the named field\n */\n public Object getValue(String fieldName) {\n GValue val = GSTSTRUCTURE_API.gst_structure_get_value(this, fieldName);\n \n if (val == null) {\n throw new InvalidFieldException(\"Object\", fieldName);\n }\n\n return val.getValue();\n }\n\n /**\n * Extract the values of the named field as a List of the provided type. If\n * the native GType of the field is a GValueArray then this method will\n * return a list of the contained values, assuming all contained values can\n * be converted to the provided Java type T. Else if the field GType can be\n * directly converted to the provided Java type T, a singleton List will be\n * returned.\n * \n * Throws {@link InvalidFieldException} if the field does not exist, or the\n * field values cannot be converted to type T.\n * \n * This method currently supports lists of values inside a GValueArray or\n * GstValueList.\n *\n * @param \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstTagList.html#GstTagFlag\n * \n */\npublic enum TagFlag implements NativeEnum \n * See upstream documentation at\n * https://gstreamer.freedesktop.org/data/doc/gstreamer/stable/gstreamer/html/GstTagList.html\n * \n */\n//@TODO consider handling Sample fields.\npublic class TagList extends MiniObject {\n\n public static final String GTYPE_NAME = \"GstTagList\";\n \n /**\n * Creates a new instance of TagList\n *\n * @param init internal initialization data.\n */\n TagList(Initializer init) {\n super(init);\n }\n\n /**\n * Constructs a new empty tag list.\n */\n public TagList() {\n super(initializer());\n }\n\n private static Initializer initializer() {\n final Pointer ptr_new_tag_list = GSTTAGLIST_API.ptr_gst_tag_list_new_empty();\n return Natives.initializer(ptr_new_tag_list);\n }\n\n /**\n * Gets the number of values of type {@code tag} stored in the list.\n *\n * @param tag the name of the tag to get the size of.\n * @return the number of values for {@code tag} in this list.\n */\n public int getValueCount(String tag) {\n return GSTTAGLIST_API.gst_tag_list_get_tag_size(this, tag);\n }\n\n /**\n * Gets all data values for a tag contained in this list.\n *\n * @param tag the name of the tag to retrieve.\n * @return the data associated with {@code tag}.\n */\n public Listelement-added signal on this Bin\n *\n * @param listener The listener to be called when an {@link Element} is\n * added.\n */\n public void connect(final ELEMENT_ADDED listener) {\n connect(ELEMENT_ADDED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Bin bin, Element elem) {\n listener.elementAdded(bin, elem);\n }\n });\n }\n\n /**\n * Disconnect the listener for the element-added signal\n *\n * @param listener The listener that was registered to receive the signal.\n */\n public void disconnect(ELEMENT_ADDED listener) {\n disconnect(ELEMENT_ADDED.class, listener);\n }\n\n /**\n * Signal emitted when an {@link Element} is removed from this Bin\n *\n * @see #connect(ELEMENT_REMOVED)\n * @see #disconnect(ELEMENT_REMOVED)\n */\n public static interface ELEMENT_REMOVED {\n\n /**\n * Called when an {@link Element} is removed from a {@link Bin}\n *\n * @param bin the Bin the element was removed from.\n * @param element the {@link Element} that was removed.\n */\n public void elementRemoved(Bin bin, Element element);\n }\n\n /**\n * Add a listener for the element-removed signal on this Bin\n *\n * @param listener The listener to be called when an {@link Element} is\n * removed.\n */\n public void connect(final ELEMENT_REMOVED listener) {\n connect(ELEMENT_REMOVED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Bin bin, Element elem) {\n listener.elementRemoved(bin, elem);\n }\n });\n }\n\n /**\n * Disconnect the listener for the element-removed signal\n *\n * @param listener The listener that was registered to receive the signal.\n */\n public void disconnect(ELEMENT_REMOVED listener) {\n disconnect(ELEMENT_REMOVED.class, listener);\n }\n\n /**\n * Signal emitted when an {@link Element} is added to sub-bin of this\n * {@link Bin}\n *\n * @see #connect(DEEP_ELEMENT_ADDED)\n * @see #disconnect(DEEP_ELEMENT_ADDED)\n */\n @Gst.Since(minor = 10)\n public static interface DEEP_ELEMENT_ADDED {\n\n /**\n * Called when an {@link Element} is added to a {@link Bin}\n *\n * Since GStreamer 1.10\n *\n * @param bin the Bin\n * @param sub_bin the Bin the element was added to.\n * @param element the {@link Element} that was added.\n */\n public void elementAdded(Bin bin, Bin sub_bin, Element element);\n }\n\n /**\n * Add a listener for the deep-element-added signal on this Bin\n *\n * @param listener The listener to be called when an {@link Element} is\n * added.\n */\n @Gst.Since(minor = 10)\n public void connect(final DEEP_ELEMENT_ADDED listener) {\n Gst.checkVersion(1, 10);\n connect(DEEP_ELEMENT_ADDED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Bin bin, Bin sub_bin, Element elem) {\n listener.elementAdded(bin, sub_bin, elem);\n }\n });\n }\n\n /**\n * Disconnect the listener for the deep-element-added signal\n *\n * @param listener The listener that was registered to receive the signal.\n */\n @Gst.Since(minor = 10)\n public void disconnect(DEEP_ELEMENT_ADDED listener) {\n disconnect(DEEP_ELEMENT_ADDED.class, listener);\n }\n\n /**\n * Signal emitted when an {@link Element} is removed from sub-bin of this\n * {@link Bin}\n *\n * @see #connect(ELEMENT_REMOVED)\n * @see #disconnect(ELEMENT_REMOVED)\n */\n @Gst.Since(minor = 10)\n public static interface DEEP_ELEMENT_REMOVED {\n\n /**\n * Called when an {@link Element} is removed from a {@link Bin}\n *\n * Since GStreamer 1.10\n *\n * @param bin the Bin\n * @param sub_bin the Bin the element was removed from.\n * @param element the {@link Element} that was removed.\n */\n public void elementRemoved(Bin bin, Bin sub_bin, Element element);\n }\n\n /**\n * Add a listener for the deep-element-removed signal on this\n * Bin\n *\n * @param listener The listener to be called when an {@link Element} is\n * removed.\n */\n @Gst.Since(minor = 10)\n public void connect(final DEEP_ELEMENT_REMOVED listener) {\n Gst.checkVersion(1, 10);\n connect(DEEP_ELEMENT_REMOVED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Bin bin, Bin sub_bin, Element elem) {\n listener.elementRemoved(bin, sub_bin, elem);\n }\n });\n }\n\n /**\n * Disconnect the listener for the deep-element-removed signal\n *\n * @param listener The listener that was registered to receive the signal.\n */\n @Gst.Since(minor = 10)\n public void disconnect(DEEP_ELEMENT_REMOVED listener) {\n disconnect(DEEP_ELEMENT_REMOVED.class, listener);\n }\n\n /**\n * Signal emitted when an {@link Element} has latency\n *\n * @see #connect(DO_LATENCY)\n * @see #disconnect(DO_LATENCY)\n */\n public static interface DO_LATENCY {\n\n /**\n * Called when an {@link Element} is removed from a {@link Bin}\n *\n * @param bin the Bin the element was removed from.\n */\n public void doLatency(Bin bin);\n }\n\n /**\n * Add a listener for the do-latency signal on this Bin\n *\n * @param listener The listener to be called when an {@link Element} is\n * removed.\n */\n public void connect(final DO_LATENCY listener) {\n connect(DO_LATENCY.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Bin bin) {\n listener.doLatency(bin);\n }\n });\n }\n\n /**\n * Disconnect the listener for the do-latency signal\n *\n * @param listener The listener that was registered to receive the signal.\n */\n public void disconnect(DO_LATENCY listener) {\n disconnect(DO_LATENCY.class, listener);\n }\n\n /**\n * Available details for pipeline graphs produced by\n * {@link #debugToDotFile(java.util.EnumSet, java.lang.String)}\n */\n public static enum DebugGraphDetails implements NativeFlags\n * Caps caps = Caps.fromString(\"video/x-raw-rgb, bpp=32, depth=24, width=640, height=480\");\n * \n * \n * Caps caps = Caps.fromString(\"video/x-raw, format=RGB, bpp=32, depth=24, width=640, height=480\");\n * \n *\n * @param caps The string representation of the caps.\n * @return The new Caps.\n */\n public static Caps fromString(String caps) {\n return new Caps(Natives.initializer(GSTCAPS_API.ptr_gst_caps_from_string(caps)));\n }\n\n /**\n * Merge two {@link Caps} together.\n * \n * time = (internal_time - internal) * rateNumerator/ rateDenominator + external\n * \n * \n *
\n * pad-added signal\n *\n * @param listener Listener to be called when a {@link Pad} is added to the\n * element.\n */\n public void connect(final PAD_ADDED listener) {\n connect(PAD_ADDED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Element elem, Pad pad) {\n listener.padAdded(elem, pad);\n }\n });\n }\n\n /**\n * Remove a listener for the pad-added signal\n *\n * @param listener The listener that was previously added.\n */\n public void disconnect(PAD_ADDED listener) {\n disconnect(PAD_ADDED.class, listener);\n }\n\n /**\n * Add a listener for the pad-added signal\n *\n * @param listener Listener to be called when a {@link Pad} is removed from\n * the element.\n */\n public void connect(final PAD_REMOVED listener) {\n connect(PAD_REMOVED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Element elem, Pad pad) {\n listener.padRemoved(elem, pad);\n }\n });\n }\n\n /**\n * Remove a listener for the pad-removed signal\n *\n * @param listener The listener that was previously added.\n */\n public void disconnect(PAD_REMOVED listener) {\n disconnect(PAD_REMOVED.class, listener);\n }\n\n /**\n * Add a listener for the no-more-pads signal\n *\n * @param listener Listener to be called when the element has finished\n * generating dynamic pads.\n */\n public void connect(final NO_MORE_PADS listener) {\n connect(NO_MORE_PADS.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public void callback(Element elem) {\n listener.noMorePads(elem);\n }\n });\n }\n\n /**\n * Remove a listener for the no-more-pads signal\n *\n * @param listener The listener that was previously added.\n */\n public void disconnect(NO_MORE_PADS listener) {\n disconnect(NO_MORE_PADS.class, listener);\n }\n\n /**\n * Link together a list of elements.\n * double, or Double.NaN if the denominator is 0\n */\n public double toDouble() {\n \treturn denominator != 0 ? ((double) numerator / denominator) : Double.NaN;\n }\n \n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/GhostPad.java",
"content": "/* \n * Copyright (c) 2019 Neil C Smith\n * Copyright (c) 2009 Levente Farkas\n * Copyright (C) 2007 Wayne Meissner\n * Copyright (C) 1999,2000 Erik Walthinsen GstException without detail message.\n */\n public GstException() {\n }\n\n\n /**\n * Constructs an instance of GstException with the specified detail message.\n * \n * @param msg the detail message.\n */\n public GstException(String msg) {\n super(msg);\n }\n \n public GstException(GError error) {\n super(error);\n }\n}\n"
},
{
"path": "src/org/freedesktop/gstreamer/GstIterator.java",
"content": "/* \n * Copyright (c) 2021 Neil C Smith\n * \n * This file is part of gstreamer-java.\n *\n * This code is free software: you can redistribute it and/or modify it under \n * the terms of the GNU Lesser General Public License version 3 only, as\n * published by the Free Software Foundation.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT \n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or \n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License \n * version 3 for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * version 3 along with this work. If not, see gst_value_deserialize.\n *\n * @param property the property to set\n * @param data the value as a valid String representation\n * @throws IllegalArgumentException if the data cannot be deserialized to\n * the required type.\n */\n public void setAsString(String property, String data) {\n GObjectAPI.GParamSpec propertySpec = findProperty(property);\n if (propertySpec == null) {\n throw new IllegalArgumentException(\"Unknown property: \" + property);\n }\n final GType propType = propertySpec.value_type;\n\n GValue propValue = new GValue();\n GVALUE_API.g_value_init(propValue, propType);\n\n boolean success = GSTVALUE_API.gst_value_deserialize(propValue, data);\n\n if (success) {\n GOBJECT_API.g_param_value_validate(propertySpec, propValue);\n GOBJECT_API.g_object_set_property(this, property, propValue);\n }\n\n GVALUE_API.g_value_unset(propValue); // Release any memory\n\n if (!success) {\n throw new IllegalArgumentException(\n \"Unable to deserialize data to required type: \"\n + propType.getTypeName());\n }\n\n }\n\n /**\n * Get the value of a GstObject property as a serialized String\n * representation of its value.\n * gst_value_serialize.\n *\n * @param property the property to get\n * @return serialized String value of property\n */\n public String getAsString(String property) {\n GObjectAPI.GParamSpec propertySpec = findProperty(property);\n if (propertySpec == null) {\n throw new IllegalArgumentException(\"Unknown property: \" + property);\n }\n final GType propType = propertySpec.value_type;\n GValue propValue = new GValue();\n GVALUE_API.g_value_init(propValue, propType);\n GOBJECT_API.g_object_get_property(this, property, propValue);\n Pointer ptr = GSTVALUE_API.gst_value_serialize(propValue);\n String ret = ptr.getString(0);\n GLIB_API.g_free(ptr);\n return ret;\n }\n\n private GObjectAPI.GParamSpec findProperty(String propertyName) {\n Pointer ptr = GOBJECT_API.g_object_class_find_property(\n getRawPointer().getPointer(0), propertyName);\n if (ptr == null) {\n return null;\n }\n return new GObjectAPI.GParamSpec(ptr);\n }\n\n /**\n * Sets the name of this object, or gives this object a guaranteed unique\n * name (if name is null).\n *\n * Returns: TRUE if the name could be set. Since Objects that have a parent\n * cannot be renamed, this function returns FALSE in those cases.\n *\n * MT safe.\n *\n * @param name new name of object\n * @return true if the name was set. Since Objects that have a parent cannot\n * be renamed, this function returns false in those cases.\n */\n public boolean setName(String name) {\n LOG.entering(\"GstObject\", \"setName\", name);\n return GSTOBJECT_API.gst_object_set_name(this, name);\n }\n\n /**\n * Returns a copy of the name of this object.\n *\n * For a nameless object, this returns null.\n *\n * @return the name of this object.\n */\n public String getName() {\n LOG.entering(\"GstObject\", \"getName\");\n return GSTOBJECT_API.gst_object_get_name(this);\n }\n\n /**\n * Returns this object's parent, if there is one.\n *\n * @return parent or null\n */\n public GstObject getParent() {\n return GSTOBJECT_API.gst_object_get_parent(this);\n }\n\n /**\n * Returns a suggestion for timestamps where buffers should be split to get\n * best controller results.\n *\n * @return the suggested timestamp or {@link ClockTime#NONE} if no\n * control-rate was set.\n */\n public long suggestNextSync() {\n return GSTOBJECT_API.gst_object_suggest_next_sync(handle.getPointer());\n }\n\n /**\n * Sets the properties of the object, according to the {@link ControlSource}\n * that (maybe) handle them and for the given timestamp.\n * linked signal on this {@link Pad}\n *\n * @param listener The listener to be called when a peer {@link Pad} is\n * linked.\n */\n public void connect(final LINKED listener) {\n connect(LINKED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public boolean callback(Pad pad, Pad peer) {\n listener.linked(pad, peer);\n return true;\n }\n });\n }\n\n /**\n * Remove a listener for the linked signal on this {@link Pad}\n *\n * @param listener The listener previously added for this signal.\n */\n public void disconnect(LINKED listener) {\n disconnect(LINKED.class, listener);\n }\n\n /**\n * Add a listener for the unlinked signal on this {@link Pad}\n *\n * @param listener The listener to be called when when a peer {@link Pad} is\n * unlinked.\n */\n public void connect(final UNLINKED listener) {\n connect(UNLINKED.class, listener, new GstCallback() {\n @SuppressWarnings(\"unused\")\n public boolean callback(Pad pad, Pad peer) {\n listener.unlinked(pad, peer);\n return true;\n }\n });\n }\n\n /**\n * Remove a listener for the unlinked signal on this\n * {@link Pad}\n *\n * @param listener The listener previously added for this signal.\n */\n public void disconnect(UNLINKED listener) {\n disconnect(UNLINKED.class, listener);\n }\n\n /**\n * Be notified of different states of pads. The provided callback is called\n * for every state that matches mask.\n * gst_plugin_desc that is a struct\n * of type GstPluginDesc. the plugin loader will check the version of the core\n * library the plugin was linked against and will create a new Plugin. It will\n * then call the #GstPluginInitFunc function that was provided in the\n * \n *
\n *