From f266e6cefc6869ec8d5da050df1bc70b32734091 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Mon, 6 Jul 2020 14:38:47 +0300 Subject: [PATCH] Update docs --- docs/gstreamer-audio/docs.md | 42 ++ docs/gstreamer-base/docs.md | 53 ++ docs/gstreamer-editing-services/docs.md | 139 ++++- docs/gstreamer-gl/docs.md | 65 +++ docs/gstreamer-pbutils/docs.md | 23 + docs/gstreamer-rtp/docs.md | 27 + docs/gstreamer-rtsp-server/docs.md | 20 + docs/gstreamer-rtsp/docs.md | 70 +++ docs/gstreamer-video/docs.md | 270 ++++++++- docs/gstreamer/docs.md | 731 +++++++++++++++++++++++- 10 files changed, 1403 insertions(+), 37 deletions(-) diff --git a/docs/gstreamer-audio/docs.md b/docs/gstreamer-audio/docs.md index 729776fb6..73854c169 100644 --- a/docs/gstreamer-audio/docs.md +++ b/docs/gstreamer-audio/docs.md @@ -619,6 +619,18 @@ handler with `GST_PAD_SET_ACCEPT_INTERSECT` and `GST_PAD_SET_ACCEPT_TEMPLATE` ## `use_` if the default pad accept-caps query handling should be used + +Maximum number of tolerated consecutive decode errors. See +`AudioDecoderExt::set_max_errors` for more details. + +Feature: `v1_18` + + +Maximum number of tolerated consecutive decode errors. See +`AudioDecoderExt::set_max_errors` for more details. + +Feature: `v1_18` + This base class is for audio encoders turning raw audio samples into encoded audio data. @@ -969,6 +981,13 @@ Configures encoder audio jitter tolerance threshold. MT safe. ## `tolerance` new tolerance + +Extra audio flags + +no valid flag + +the position array explicitly + contains unpositioned channels. Enum value describing the most common audio formats. @@ -1063,6 +1082,19 @@ encoded audio format 32-bit floating point samples, native endianness 64-bit floating point samples, native endianness + +The different audio flags that a format info can have. + +integer samples + +float samples + +signed samples + +complex layout + +the format can be used in +`GstAudioFormatUnpack` and `GstAudioFormatPack` functions Information describing audio properties. This information can be filled in from GstCaps with `AudioInfo::from_caps`. @@ -1144,6 +1176,16 @@ Layout of the audio samples for the different channels. interleaved audio non-interleaved audio + +The different flags that can be used when packing and unpacking. + +No flag + +When the source has a smaller depth + than the target format, set the least significant bits of the target + to 0. This is likely slightly faster but less accurate. When this flag + is not specified, the most significant bits of the source are duplicated + in the least significant bits of the destination. The format of the samples in the ringbuffer. diff --git a/docs/gstreamer-base/docs.md b/docs/gstreamer-base/docs.md index c09374d12..b21468859 100644 --- a/docs/gstreamer-base/docs.md +++ b/docs/gstreamer-base/docs.md @@ -156,6 +156,20 @@ the number of bytes to copy # Returns A new `glib::Bytes` structure containing the copied data. + +Get the distance in bytes since the last buffer with the +`gst::BufferFlags::Discont` flag. + +The distance will be reset to 0 for all buffers with +`gst::BufferFlags::Discont` on them, and then calculated for all other +following buffers based on their size. + +Feature: `v1_10` + + +# Returns + +The offset. Can be `GST_BUFFER_OFFSET_NONE`. Get the DTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT flag, or GST_CLOCK_TIME_NONE. @@ -790,6 +804,18 @@ Enables the emission of signals such as `AggregatorPad::buffer-consumed` Feature: `v1_16` + + +Start at running time 0. + +Start at the running time of +the first buffer that is received. + +Start at the running time +selected by the `start-time` property. + +Feature: `v1_18` + This base class is for parser elements that process data and splits it into separate audio/video/whatever frames. @@ -1157,6 +1183,9 @@ a newly-allocated `BaseParseFrame`. Free with Copies a `BaseParseFrame`. +Feature: `v1_12_1` + + # Returns A copy of `self` @@ -1168,6 +1197,30 @@ all public fields are zero-ed and a private flag is set to make sure `BaseParseFrame::free` only frees the contents but not the actual frame. Use this function to initialise a `BaseParseFrame` allocated on the stack. + +Flags to be used in a `BaseParseFrame`. + +no flag + +set by baseclass if current frame + is passed for processing to the subclass for the first time + (and not set on subsequent calls with same data). + +set to indicate this buffer should not be + counted as frame, e.g. if this frame is dependent on a previous one. + As it is not counted as a frame, bitrate increases but frame to time + conversions are maintained. + +`pre_push_frame` can set this to indicate + that regular segment clipping can still be performed (as opposed to + any custom one having been done). + +indicates to `finish_frame` that the + the frame should be dropped (and might be handled internally by subclass) + +indicates to `finish_frame` that the + the frame should be queued for now and processed fully later + when the first non-queued frame is finished `BaseSink` is the base class for sink elements in GStreamer, such as xvimagesink or filesink. It is a layer on top of `gst::Element` that provides a diff --git a/docs/gstreamer-editing-services/docs.md b/docs/gstreamer-editing-services/docs.md index e8ffdc968..a54793d6f 100644 --- a/docs/gstreamer-editing-services/docs.md +++ b/docs/gstreamer-editing-services/docs.md @@ -187,8 +187,7 @@ call `glib::MainContext::push_thread_default` in a new thread before calling `ges_init`. Example of an asynchronous asset request: - -```text +``` c // The request callback static void asset_loaded_cb (GESAsset * source, GAsyncResult * res, gpointer user_data) @@ -198,14 +197,14 @@ asset_loaded_cb (GESAsset * source, GAsyncResult * res, gpointer user_data) asset = ges_asset_request_finish (res, &error); if (asset) { - g_print ("The file: %s is usable as a FileSource", + g_print ("The file: %s is usable as a GESUriClip", ges_asset_get_id (asset)); } else { - g_print ("The file: %s is *not* usable as a FileSource because: %s", + g_print ("The file: %s is *not* usable as a GESUriClip because: %s", ges_asset_get_id (source), error->message); } - gst_object_unref (mfs); + gst_object_unref (asset); } // The request: @@ -728,6 +727,9 @@ This method can also fail if the adding the track element to the track would break a configuration rule of the corresponding `Timeline`, such as causing three sources to overlap at a single time, or causing a source to completely overlap another in the same track. + +Feature: `v1_18` + ## `child` A child of `self` ## `track` @@ -935,6 +937,9 @@ using this position to trim the end of a clip. See `ClipExt::get_internal_time_from_timeline_time`, which performs the reverse, or `ClipExt::get_timeline_time_from_source_frame` which does the same conversion, but using frame numbers. + +Feature: `v1_18` + ## `child` An `TrackElement:active` child of `self` with a `TrackElement:track` @@ -1122,6 +1127,9 @@ If the duration-limit would ever go below the current `TimelineElement:duration` of the clip due to a change in the above variables, its `TimelineElement:duration` will be set to the new limit. + +Feature: `v1_18` + The layer this clip lies in. @@ -1437,9 +1445,14 @@ The element is edited in slide mode (not yet (`Edge::Start` and `Edge::End`) is not defined. The element can not shift layers under this mode. -Currently we only support effects with 1 sinkpad and 1 sourcepad -with the exception of `gesaudiomixer` and `gescompositor` which -can be used as effects. +Currently we only support effects with N sinkpads and one single srcpad. +Apart from `gesaudiomixer` and `gescompositor` which can be used as effects +and where sinkpads will be requested as needed based on the timeline topology +GES will always request at most one sinkpad per effect (when required). + +> Note: GES always adds converters (`audioconvert ! audioresample ! +> audioconvert` for audio effects and `videoconvert` for video effects) to +> make it simpler for end users. # Implements @@ -1742,6 +1755,9 @@ if `self` refused to add `clip`. Gets whether the layer is active for the given track. See `LayerExt::set_active_for_tracks`. + +Feature: `v1_18` + ## `track` The `Track` to check if `self` is currently active for @@ -1823,6 +1839,9 @@ active in the track, regardless of their individual Note that by default a layer will be active for all of its timeline's tracks. + +Feature: `v1_18` + ## `active` Whether elements in `tracks` should be active or not ## `tracks` @@ -1856,6 +1875,9 @@ The priority to set Will be emitted whenever the layer is activated or deactivated for some `Track`. See `LayerExt::set_active_for_tracks`. + +Feature: `v1_18` + ## `active` Whether `layer` has been made active or de-active in the `tracks` ## `tracks` @@ -2022,9 +2044,14 @@ to `location` using the given `format`, `height` and `width`. Sets the `Pipeline:mode` of the pipeline. -Note that the pipeline will be set to `gst::State::Null` during this call -to perform the necessary changes. You will need to set the state again -yourself after calling this. +Note that the pipeline will be set to `gst::State::Null` during this call to +perform the necessary changes. You will need to set the state again yourself +after calling this. + +> **NOTE**: [Rendering settings](ges_pipeline_set_render_settings) need to be +> set before setting `mode` to `PipelineFlags::Render` or +> `PipelineFlags::SmartRender`, the call to this method will fail +> otherwise. ## `mode` The mode to set for `self` @@ -2109,6 +2136,25 @@ The video sink used for preview. This exposes the The video sink used for preview. This exposes the `playsink:video-sink` property of the internal `playsink`. + +The various modes a `Pipeline` can be configured to. + +Output the `Pipeline:timeline`'s +audio to the soundcard + +Output the `Pipeline:timeline`'s +video to the screen + +Output both the `Pipeline:timeline`'s +audio and video to the soundcard and screen (default) + +Render the `Pipeline:timeline` with +forced decoding (the underlying `encodebin` has its +`encodebin:avoid-reencoding` property set to `false`) + +Render the `Pipeline:timeline`, +avoiding decoding/reencoding (the underlying `encodebin` has its +`encodebin:avoid-reencoding` property set to `true`) The `Project` is used to control a set of `Asset` and is a `Asset` with `GES_TYPE_TIMELINE` as `extractable_type` itself. That @@ -2613,6 +2659,9 @@ with the given `name`, or `None` if it was not found. This method allows you to convert a timeline `gst::ClockTime` into its corresponding `FrameNumber` in the timeline's output. + +Feature: `v1_18` + ## `timestamp` The timestamp to get the corresponding frame number of @@ -2624,6 +2673,9 @@ This method allows you to convert a timeline output frame number into a timeline `gst::ClockTime`. For example, this time could be used to seek to a particular frame in the timeline's output, or as the edit position for an element within the timeline. + +Feature: `v1_18` + ## `frame_number` The frame number to get the corresponding timestamp of in the timeline coordinates @@ -3624,6 +3676,9 @@ Emitted when the element has a new child property registered. See Note that some GES elements will be automatically created with pre-registered children properties. You can use `TimelineElementExt::list_children_properties` to list these. + +Feature: `v1_18` + ## `prop_object` The child whose property has been registered ## `prop` @@ -3631,6 +3686,9 @@ The specification for the property that has been registered Emitted when the element has a child property unregistered. See `TimelineElementExt::remove_child_property`. + +Feature: `v1_18` + ## `prop_object` The child whose property has been unregistered ## `prop` @@ -3979,7 +4037,7 @@ The element that was removed The capabilities used to choose the output of the `Track`'s elements. Internally, this is used to select output streams when several may be available, by determining whether its `gst::Pad` is -compatible (see `nlecomposition:caps` for `nlecomposition`). As such, +compatible (see `NleObject:caps` for `nlecomposition`). As such, this is used as a weaker indication of the desired output type of the track, **before** the `Track:restriction-caps` is applied. Therefore, this should be set to a *generic* superset of the @@ -3997,7 +4055,7 @@ Default value: `GST_CAPS_ANY`. The capabilities used to choose the output of the `Track`'s elements. Internally, this is used to select output streams when several may be available, by determining whether its `gst::Pad` is -compatible (see `nlecomposition:caps` for `nlecomposition`). As such, +compatible (see `NleObject:caps` for `nlecomposition`). As such, this is used as a weaker indication of the desired output type of the track, **before** the `Track:restriction-caps` is applied. Therefore, this should be set to a *generic* superset of the @@ -4226,7 +4284,7 @@ be initialized if it is initialized with 0 # Returns -`true` if the property was found, `false` otherwize. +`true` if the property was found, `false` otherwise. Gets a property of a child of `self`. @@ -4306,6 +4364,9 @@ The track-type of `self`. Gets `TrackElement:has-internal-source` for the element. +Feature: `v1_18` + + # Returns `true` if `self` can have its 'internal time' properties set. @@ -4436,7 +4497,7 @@ The value # Returns -`true` if the property was set, `false` otherwize. +`true` if the property was set, `false` otherwise. Sets a property of a child of `self`. @@ -4488,9 +4549,17 @@ Sets `TrackElement:has-internal-source` for the element. If this is set to `false`, this method will also set the `TimelineElement:in-point` of the element to 0 and its `TimelineElement:max-duration` to `GST_CLOCK_TIME_NONE`. + +Feature: `v1_18` + ## `has_internal_source` Whether the `self` should be allowed to have its 'internal time' properties set. + +# Returns + +`false` if `has_internal_source` is forbidden for `self` and +`true` in any other case. Sets the `TrackElement:track-type` for the element. ## `type_` @@ -4523,6 +4592,9 @@ See `TrackElementExt::clamp_control_source` for how this is done per control source. Default value: `true` + +Feature: `v1_18` + Whether the control sources on the element (see `TrackElementExt::set_control_source`) will be automatically @@ -4533,6 +4605,9 @@ See `TrackElementExt::clamp_control_source` for how this is done per control source. Default value: `true` + +Feature: `v1_18` + This property is used to determine whether the 'internal time' properties of the element have any meaning. In particular, unless @@ -4568,6 +4643,9 @@ time at which the subtitle file runs out of data. Note that GES can not support track elements that have both internal content and manipulate the timing of their data streams (time effects). + +Feature: `v1_18` + This property is used to determine whether the 'internal time' properties of the element have any meaning. In particular, unless @@ -4603,6 +4681,9 @@ time at which the subtitle file runs out of data. Note that GES can not support track elements that have both internal content and manipulate the timing of their data streams (time effects). + +Feature: `v1_18` + The track that this element belongs to, or `None` if it does not belong to a track. @@ -4616,6 +4697,23 @@ The track type of the element, which determines the type of track the element can be added to (see `Track:track-type`). This should correspond to the type of data that the element can produce or process. + +Types of content handled by a track. If the content is not one of +`TrackType::Audio`, `TrackType::Video` or `TrackType::Text`, +the user of the `Track` must set the type to `TrackType::Custom`. + +`TrackType::Unknown` is for internal purposes and should not be used +by users + +A track of unknown type (i.e. invalid) + +An audio track + +A video track + +A text (subtitle) track + +A custom-content track Represents all the output streams from a particular uri. It is assumed that the URI points to a file of some type. @@ -4631,6 +4729,11 @@ Trait containing all `UriClip` methods. [`UriClip`](struct.UriClip.html) Creates a new `UriClip` for the provided `uri`. + +> **WARNING**: This function might 'discover` @uri **synchrounously**, it is +> an IO and processing intensive task that you probably don't want to run in +> an application mainloop. Have a look at #ges_asset_request_async to see how +> to make that operation happen **asynchronously**. ## `uri` the URI the source should control @@ -4784,6 +4887,9 @@ a Gets Whether the file represented by `self` is an image or not +Feature: `v1_18` + + # Returns Whether the file represented by `self` is an image or not @@ -4826,6 +4932,9 @@ a `UriClipAsset` Check if `self` contains a single image +Feature: `v1_18` + + # Returns `true` if the video stream corresponds to an image (i.e. only diff --git a/docs/gstreamer-gl/docs.md b/docs/gstreamer-gl/docs.md index 39b1c1bb1..1c57ed035 100644 --- a/docs/gstreamer-gl/docs.md +++ b/docs/gstreamer-gl/docs.md @@ -1,4 +1,18 @@ + + +no API + +Desktop OpenGL up to and including 3.1. The + compatibility profile when the OpenGL version is >= 3.2 + +Desktop OpenGL >= 3.2 core profile + +OpenGL ES 1.x + +OpenGL ES 2.x and 3.x + +Any OpenGL API `GLBaseFilter` handles the nitty gritty details of retrieving an OpenGL context. It also provided some wrappers around `gst_base::BaseTransform`'s @@ -623,6 +637,29 @@ pointer to a display (or 0) # Returns A `EGLDisplay` or `EGL_NO_DISPLAY` + + +no display type + +X11 display + +Wayland display + +Cocoa display + +Win32 display + +Dispmanx display + +EGL display + +Vivante Framebuffer display + +Mesa3D GBM display + +EGLDevice display (Since: 1.18) + +any display type the contents of a `GLDisplayWayland` are private and should only be accessed through the provided API @@ -794,6 +831,22 @@ Opaque `GLOverlayCompositor` object # Implements [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + + +no platform + +the EGL platform used primarily with the X11, wayland + and android window systems as well as on embedded Linux + +the GLX platform used primarily with the X11 window system + +the WGL platform used primarily on Windows + +the CGL platform used primarily on OS X + +the EAGL platform used primarily on iOS + +any OpenGL platform no query @@ -809,6 +862,18 @@ Compilation error occurred Link error occurred General program error occurred + +GLSL profiles + +no profile supported/available + +OpenGL|ES profile + +OpenGL core profile + +OpenGL compatibility profile + +any OpenGL/OpenGL|ES profile `GLSLStage` holds and represents a single OpenGL shader stage. diff --git a/docs/gstreamer-pbutils/docs.md b/docs/gstreamer-pbutils/docs.md index bc8b15c4a..9edbd8304 100644 --- a/docs/gstreamer-pbutils/docs.md +++ b/docs/gstreamer-pbutils/docs.md @@ -331,6 +331,21 @@ the discovery timed-out the discoverer was already discovering a file Some plugins are missing for full discovery + +You can use these flags to control what is serialized by +`DiscovererInfo::to_variant` + +Serialize only basic information, excluding +caps, tags and miscellaneous information + +Serialize the caps for each stream + +Serialize the tags for each stream + +Serialize miscellaneous information for each stream + +Serialize all the available info, including +caps, tags and miscellaneous information Base structure for information concerning a media stream. Depending on the stream type, one can find more media-specific information in @@ -836,6 +851,14 @@ The description of the `self`. # Returns The name of the `self`. + + +Feature: `v1_18` + + +# Returns + +The path to the `self` file. ## `name` the name of the profile to retrieve diff --git a/docs/gstreamer-rtp/docs.md b/docs/gstreamer-rtp/docs.md index 13b1b0f93..57a6d5e87 100644 --- a/docs/gstreamer-rtp/docs.md +++ b/docs/gstreamer-rtp/docs.md @@ -93,6 +93,33 @@ VoIP Metrics Report Block Feature: `v1_16` + +Additional RTP buffer flags. These flags can potentially be used on any +buffers carrying RTP packets. + +Note that these are only valid for `gst::Caps` of type: application/x-rtp (x-rtcp). +They can conflict with other extended buffer flags. + +The `gst::Buffer` was once wrapped + in a retransmitted packet as specified by RFC 4588. + +The packet represents redundant RTP packet. + The flag is used in gstrtpstorage to be able to hold the packetback + and use it only for recovery from packet loss. + Since: 1.14 + +Offset to define more flags. + +Feature: `v1_10` + + +Additional mapping flags for `RTPBuffer::map`. + +Skip mapping and validation of RTP + padding and RTP pad count when present. Useful for buffers where + the padding may be encrypted. + +Offset to define more flags Standard predefined fixed payload types. diff --git a/docs/gstreamer-rtsp-server/docs.md b/docs/gstreamer-rtsp-server/docs.md index fa6424e12..9874cf2dc 100644 --- a/docs/gstreamer-rtsp-server/docs.md +++ b/docs/gstreamer-rtsp-server/docs.md @@ -10,6 +10,20 @@ a copy of `self`. Free `self` and releasing it back into the pool when owned by a pool. + +Flags used to control allocation of addresses + +no flags + +an IPv4 address + +and IPv6 address + +address with an even port + +a multicast address + +a unicast address An address pool, all member are private @@ -3319,3 +3333,9 @@ pointer becomes invalid when you free the token. This function checks if `self` is writable and will never return `None`. MT safe. + +The supported modes of the media. + +Transport supports PLAY mode + +Transport supports RECORD mode diff --git a/docs/gstreamer-rtsp/docs.md b/docs/gstreamer-rtsp/docs.md index 2a51c25a2..72121975e 100644 --- a/docs/gstreamer-rtsp/docs.md +++ b/docs/gstreamer-rtsp/docs.md @@ -11,6 +11,12 @@ digest authentication RTSP Authentication parameter Feature: `v1_12` + +The possible events for the connection. + +connection is readable + +connection is writable The possible network families. @@ -21,6 +27,50 @@ internet internet V6 Enumeration of rtsp header fields + +The different transport methods. + +invalid transport flag + +stream data over UDP + +stream data over UDP multicast + +stream data over TCP + +stream data tunneled over HTTP. + +encrypt TCP and HTTP with TLS + +The different supported RTSP methods. + +invalid method + +the DESCRIBE method + +the ANNOUNCE method + +the GET_PARAMETER method + +the OPTIONS method + +the PAUSE method + +the PLAY method + +the RECORD method + +the REDIRECT method + +the SETUP method + +the SET_PARAMETER method + +the TEARDOWN method + +the GET method (HTTP). + +the POST method (HTTP). The type of a message. @@ -35,6 +85,18 @@ HTTP request message. HTTP response message. data message + +The transfer profile to use. + +invalid profile + +the Audio/Visual profile (RFC 3551) + +the secure Audio/Visual profile (RFC 3711) + +the Audio/Visual profile with feedback (RFC 4585) + +the secure Audio/Visual profile with feedback (RFC 5124) Different possible time range units. @@ -113,6 +175,14 @@ end frames and subframes UTC time + +The transfer mode to use. + +invalid tansport mode + +transfer RTP data + +transfer RDT (RealMedia) data Provides helper functions to handle RTSP urls. diff --git a/docs/gstreamer-video/docs.md b/docs/gstreamer-video/docs.md index e0d93d032..38be0105f 100644 --- a/docs/gstreamer-video/docs.md +++ b/docs/gstreamer-video/docs.md @@ -105,6 +105,54 @@ multiply all alpha with `GST_VIDEO_CONVERTER_OPT_ALPHA_VALUE`. When the input format has no alpha but the output format has, the alpha value will be set to `GST_VIDEO_CONVERTER_OPT_ALPHA_VALUE` + +Additional video buffer flags. These flags can potentially be used on any +buffers carrying closed caption data, or video data - even encoded data. + +Note that these are only valid for `gst::Caps` of type: video/... and caption/... +They can conflict with other extended buffer flags. + +If the `gst::Buffer` is interlaced. In mixed + interlace-mode, this flags specifies if the frame is + interlaced or progressive. + +If the `gst::Buffer` is interlaced, then the first field + in the video frame is the top field. If unset, the + bottom field is first. + +If the `gst::Buffer` is interlaced, then the first field + (as defined by the `VideoBufferFlags::Tff` flag setting) + is repeated. + +If the `gst::Buffer` is interlaced, then only the + first field (as defined by the `VideoBufferFlags::Tff` + flag setting) is to be displayed (Since: 1.16). + +The `gst::Buffer` contains one or more specific views, + such as left or right eye view. This flags is set on + any buffer that contains non-mono content - even for + streams that contain only a single viewpoint. In mixed + mono / non-mono streams, the absence of the flag marks + mono buffers. + +When conveying stereo/multiview content with + frame-by-frame methods, this flag marks the first buffer + in a bundle of frames that belong together. + +The video frame has the top field only. This is the + same as GST_VIDEO_BUFFER_FLAG_TFF | + GST_VIDEO_BUFFER_FLAG_ONEFIELD (Since: 1.16). + Use GST_VIDEO_BUFFER_IS_TOP_FIELD() to check for this flag. + +The video frame has the bottom field only. This is + the same as GST_VIDEO_BUFFER_FLAG_ONEFIELD + (GST_VIDEO_BUFFER_FLAG_TFF flag unset) (Since: 1.16). + Use GST_VIDEO_BUFFER_IS_BOTTOM_FIELD() to check for this flag. + +The `gst::Buffer` contains the end of a video field or frame + boundary such as the last subframe or packet (Since: 1.18). + +Offset to define more flags @@ -160,6 +208,26 @@ only perform chroma upsampling only perform chroma downsampling disable chroma resampling + +Various Chroma sitings. + +unknown cositing + +no cositing + +chroma is horizontally cosited + +chroma is vertically cosited + +choma samples are sited on alternate lines + +chroma samples cosited with luma samples + +jpeg style cositing, also for mpeg1 and mjpeg + +mpeg2 style cositing + +DV style cositing A `VideoCodecFrame` represents a video frame both in raw and encoded form. @@ -189,6 +257,16 @@ a `GDestroyNotify` Decreases the refcount of the frame. If the refcount reaches 0, the frame will be freed. + +Flags for `VideoCodecFrame` + +is the frame only meant to be decoded + +is the frame a synchronization point (keyframe) + +should the output frame be made a keyframe + +should the encoder output stream headers Structure representing the state of an incoming or outgoing video stream for encoders and decoders. @@ -681,6 +759,18 @@ handler with `GST_PAD_SET_ACCEPT_INTERSECT` and `GST_PAD_SET_ACCEPT_TEMPLATE` ## `use_` if the default pad accept-caps query handling should be used + +Maximum number of tolerated consecutive decode errors. See +`VideoDecoderExt::set_max_errors` for more details. + +Feature: `v1_18` + + +Maximum number of tolerated consecutive decode errors. See +`VideoDecoderExt::set_max_errors` for more details. + +Feature: `v1_18` + If set to `true` the decoder will handle QoS events received from downstream elements. @@ -888,6 +978,16 @@ a `VideoCodecFrame` # Returns max decoding time. + +Returns the minimum force-keyunit interval, see `VideoEncoderExt::set_min_force_key_unit_interval` +for more details. + +Feature: `v1_18` + + +# Returns + +the minimum force-keyunit interval Get the oldest unfinished pending `VideoCodecFrame` @@ -954,6 +1054,15 @@ Informs baseclass of encoding latency. minimum latency ## `max_latency` maximum latency + +Sets the minimum interval for requesting keyframes based on force-keyunit +events. Setting this to 0 will allow to handle every event, setting this to +`GST_CLOCK_TIME_NONE` causes force-keyunit events to be ignored. + +Feature: `v1_18` + +## `interval` +minimum interval Request minimal value for PTS passed to handle_frame. @@ -995,6 +1104,18 @@ Feature: `v1_14` ## `enabled` the new qos value. + +Minimum interval between force-keyunit requests in nanoseconds. See +`VideoEncoderExt::set_min_force_key_unit_interval` for more details. + +Feature: `v1_18` + + +Minimum interval between force-keyunit requests in nanoseconds. See +`VideoEncoderExt::set_min_force_key_unit_interval` for more details. + +Feature: `v1_18` + Field order of interlaced content. This is only valid for interlace-mode=interleaved and not interlace-mode=mixed. In the case of @@ -1019,6 +1140,16 @@ to implement frame dropping. # Implements [`gst_base::BaseTransformExt`](../gst_base/trait.BaseTransformExt.html), [`gst::ElementExt`](../gst/trait.ElementExt.html), [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Extra video flags + +no flags + +a variable fps is selected, fps_n and fps_d + denote the maximum fps of the video + +Each color has been scaled by the alpha + value. Enum value describing the most common video formats. @@ -1221,6 +1352,63 @@ packed 4:2:2 YUV, 12 bits per channel (Y-U-Y-V) (Since: 1.18) packed 4:4:4:4 YUV, 12 bits per channel(U-Y-V-A...) (Since: 1.18) packed 4:4:4:4 YUV, 12 bits per channel(U-Y-V-A...) (Since: 1.18) + +The different video flags that a format info can have. + +The video format is YUV, components are numbered + 0=Y, 1=U, 2=V. + +The video format is RGB, components are numbered + 0=R, 1=G, 2=B. + +The video is gray, there is one gray component + with index 0. + +The video format has an alpha components with + the number 3. + +The video format has data stored in little + endianness. + +The video format has a palette. The palette + is stored in the second plane and indexes are stored in the first plane. + +The video format has a complex layout that + can't be described with the usual information in the `VideoFormatInfo`. + +This format can be used in a + `GstVideoFormatUnpack` and `GstVideoFormatPack` function. + +The format is tiled, there is tiling information + in the last plane. + +Extra video frame flags + +no flags + +The video frame is interlaced. In mixed + interlace-mode, this flag specifies if the frame is interlaced or + progressive. + +The video frame has the top field first + +The video frame has the repeat flag + +The video frame has one field + +The video contains one or + more non-mono views + +The video frame is the first + in a set of corresponding views provided as sequential frames. + +The video frame has the top field only. This + is the same as GST_VIDEO_FRAME_FLAG_TFF | GST_VIDEO_FRAME_FLAG_ONEFIELD + (Since: 1.16). + +The video frame has the bottom field + only. This is the same as GST_VIDEO_FRAME_FLAG_ONEFIELD + (GST_VIDEO_FRAME_FLAG_TFF flag unset) (Since: 1.16). disable gamma handling @@ -1396,6 +1584,42 @@ use the output color matrix to convert to and from R'G'B disable color matrix conversion. + +GstVideoMultiviewFlags are used to indicate extra properties of a +stereo/multiview stream beyond the frame layout and buffer mapping +that is conveyed in the `VideoMultiviewMode`. + +No flags + +For stereo streams, the + normal arrangement of left and right views is reversed. + +The left view is vertically + mirrored. + +The left view is horizontally + mirrored. + +The right view is + vertically mirrored. + +The right view is + horizontally mirrored. + +For frame-packed + multiview modes, indicates that the individual + views have been encoded with half the true width or height + and should be scaled back up for display. This flag + is used for overriding input layout interpretation + by adjusting pixel-aspect-ratio. + For side-by-side, column interleaved or checkerboard packings, the + pixel width will be doubled. For row interleaved and top-bottom + encodings, pixel height will be doubled. + +The video stream contains both + mono and multiview portions, signalled on each buffer by the + absence or presence of the `VideoBufferFlags::MultipleView` + buffer flag. `VideoMultiviewFramePacking` represents the subset of `VideoMultiviewMode` values that can be applied to any video frame without needing extra metadata. @@ -1694,13 +1918,13 @@ main (int argc, char **argv) ```text -#include <glib.h> -#include <gst/gst.h> -#include <gst/video/videooverlay.h> +#include ; +#include ; +#include ; -#include <QApplication> -#include <QTimer> -#include <QWidget> +#include ; +#include ; +#include ; int main(int argc, char *argv[]) { @@ -1844,6 +2068,28 @@ specific window (e.g. an XWindow on X11). Passing 0 as the `handle` will tell the overlay to stop using that window and create an internal one. ## `handle` a handle referencing the window. + +Overlay format flags. + +no flags + +RGB are premultiplied by A/255. + +a global-alpha value != 1 is set. + +The different flags that can be used when packing and unpacking. + +No flag + +When the source has a smaller depth + than the target format, set the least significant bits of the target + to 0. This is likely slightly faster but less accurate. When this flag + is not specified, the most significant bits of the source are duplicated + in the least significant bits of the destination. + +The source is interlaced. The unpacked + format will be interlaced as well with each line containing + information from alternating fields. (Since: 1.2) Different primaries conversion modes @@ -2200,6 +2446,18 @@ field 2 ':' for non-drop-frame, non-interlaced content and for non-drop-frame interlaced field 2 '.' for non-drop-frame interlaced field 1 + +Flags related to the time code information. +For drop frame, only 30000/1001 and 60000/1001 frame rates are supported. + +No flags + +Whether we have drop frame rate + +Whether we have interlaced video + +Feature: `v1_10` + A representation of a difference between two `VideoTimeCode` instances. Will not necessarily correspond to a real timecode (e.g. 00:00:10;00) diff --git a/docs/gstreamer/docs.md b/docs/gstreamer/docs.md index 945c872d0..b48f666e2 100644 --- a/docs/gstreamer/docs.md +++ b/docs/gstreamer/docs.md @@ -485,6 +485,20 @@ The messages are converted to an ELEMENT message with the bin as the source. The structure of the message is named 'GstBinForwarded' and contains a field named 'message' of type GST_TYPE_MESSAGE that contains the original forwarded message. + +GstBinFlags are a set of flags specific to bins. Most are set/used +internally. They can be checked using the GST_OBJECT_FLAG_IS_SET () macro, +and (un)set using GST_OBJECT_FLAG_SET () and GST_OBJECT_FLAG_UNSET (). + +don't resync a state change when elements are + added or linked in the bin (Since: 1.0.5) + +Indicates whether the bin can handle elements + that add/remove source pads at any point in time without + first posting a no-more-pads signal (Since: 1.10) + +the last enum in the series of flags for bins. +Derived classes can use this as first value in a list of flags. Buffers are the basic unit of data transfer in GStreamer. They contain the timing and offset along with other arbitrary metadata that is associated @@ -1000,6 +1014,17 @@ a pointer to the maxsize # Returns total size of `length` memory blocks starting at `idx` in `self`. + +Gives the status of a specific flag on a buffer. + +Feature: `v1_10` + +## `flags` +the `BufferFlags` flag to check. + +# Returns + +`true` if all flags in `flags` are found on `self`. Insert the memory block `mem` to `self` at `idx`. This function takes ownership of `mem` and thus doesn't increase its refcount. @@ -1303,6 +1328,82 @@ pointer to a `Buffer` that will # Returns `true` when `obuf` was different from `nbuf`. + +A set of flags that can be provided to the `Buffer::copy_into` +function to specify which items should be copied. + +copy nothing + +flag indicating that buffer flags should be copied + +flag indicating that buffer pts, dts, + duration, offset and offset_end should be copied + +flag indicating that buffer meta should be + copied + +flag indicating that buffer memory should be reffed + and appended to already existing memory. Unless the memory is marked as + NO_SHARE, no actual copy of the memory is made but it is simply reffed. + Add `BufferCopyFlags::Deep` to force a real copy. + +flag indicating that buffer memory should be + merged + +flag indicating that memory should always be + copied instead of reffed (Since: 1.2) + +A set of buffer flags used to describe properties of a `Buffer`. + +the buffer is live data and should be discarded in + the PAUSED state. + +the buffer contains data that should be dropped + because it will be clipped against the segment + boundaries or because it does not contain data + that should be shown to the user. + +the buffer marks a data discontinuity in the stream. + This typically occurs after a seek or a dropped buffer + from a live or network source. + +the buffer timestamps might have a discontinuity + and this buffer is a good point to resynchronize. + +the buffer data is corrupted. + +the buffer contains a media specific marker. for + video this is the end of a frame boundary, for audio + this is the start of a talkspurt. + +the buffer contains header information that is + needed to decode the following data. + +the buffer has been created to fill a gap in the + stream and contains media neutral data (elements can + switch to optimized code path that ignores the buffer + content). + +the buffer can be dropped without breaking the + stream, for example to reduce bandwidth. + +this unit cannot be decoded independently. + +this flag is set when memory of the buffer + is added/removed + +Elements which write to disk or permanent + storage should ensure the data is synced after + writing the contents of this buffer. (Since: 1.6) + +This buffer is important and should not be dropped. + This can be used to mark important buffers, e.g. to flag + RTP packets carrying keyframes or codec setup data for RTP + Forward Error Correction purposes, or to prevent still video + frames from being dropped by elements due to QoS. (Since: 1.14) + +additional media specific flags can be added starting from + this flag. Buffer lists are an object containing a list of buffers. @@ -1716,6 +1817,21 @@ Enable or disable the flushing state of a `self` without freeing or allocating buffers. ## `flushing` whether to start or stop flushing + +Additional flags to control the allocation of a buffer + +no flags + +buffer is keyframe + +when the bufferpool is empty, acquire_buffer +will by default block until a buffer is released into the pool again. Setting +this flag makes acquire_buffer return `FlowReturn::Eos` instead of blocking. + +buffer is discont + +last flag, subclasses can use private flags + starting from this value. The different types of buffering methods. @@ -3443,6 +3559,25 @@ The type of the clock entry a single shot timeout a periodic timeout request + +The capabilities of this clock + +clock can do a single sync timeout request + +clock can do a single async timeout request + +clock can do sync periodic timeout requests + +clock can do async periodic timeout callbacks + +clock's resolution can be changed + +clock can be slaved to a master clock + +clock needs to be synced before it can be used + (Since: 1.6) + +subclasses can add additional flags starting from this flag The return value of a clock operation. @@ -3926,6 +4061,65 @@ a newly allocated string formatted according Atomically decrements the reference count of `self` by one. When the reference count reaches zero, the structure is freed. + +These are some terminal style flags you can use when creating your +debugging categories to make them stand out in debugging output. + +Use black as foreground color. + +Use red as foreground color. + +Use green as foreground color. + +Use yellow as foreground color. + +Use blue as foreground color. + +Use magenta as foreground color. + +Use cyan as foreground color. + +Use white as foreground color. + +Use black as background color. + +Use red as background color. + +Use green as background color. + +Use yellow as background color. + +Use blue as background color. + +Use magenta as background color. + +Use cyan as background color. + +Use white as background color. + +Make the output bold. + +Underline the output. + +Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE() +and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(). + +show caps-name on edges + +show caps-details on edges + +show modified parameters on + elements + +show element states + +show full element parameter values even + if they are very long + +show all the typical details that one might want + +show all details regardless of how large or + verbose they make the resulting output The level defines the importance of a debugging message. The more important a message is, the greater the probability that the debugging system outputs it. @@ -5761,6 +5955,22 @@ a `ElementFactoryListType` # Returns `true` if `self` is of `type_`. + +The standard flags that an element may have. + +ignore state changes from parent + +the element is a sink + +the element is a source. + +the element can provide a clock + +the element requires a clock + +the element can use an index + +offset to define more flags The event class provides factory methods to construct events for sending and functions to query (parse) received events. @@ -7021,6 +7231,11 @@ This function is most useful in language bindings and when subclassing function. Call this function directly after a call to g_object_new (GST_TYPE_GHOST_PAD, "direction", `dir`, ..., NULL). +# Deprecated + +This function is deprecated since 1.18 and does nothing +anymore. + # Returns `true` if the construction succeeds, `false` otherwise. @@ -7062,6 +7277,24 @@ used when the library doesn't accept settings. used when the library generated an encoding error. the number of library error types. + +Flags for wrapped memory. + +memory is readonly. It is not allowed to map the +memory with `MapFlags::Write`. + +memory must not be shared. Copies will have to be +made when this memory needs to be shared between buffers. + +the memory prefix is filled with 0 bytes + +the memory padding is filled with 0 bytes + +the memory is physically contiguous. (Since: 1.2) + +the memory can't be mapped via `Memory::map` without any preconditions. (Since: 1.2) + +first flag that can be used for custom purposes Messages are implemented as a subclass of `MiniObject` with a generic `Structure` as the content. This allows for writing custom messages without @@ -7078,7 +7311,7 @@ The basic use pattern of posting a message on a `Bus` is as follows: ``` A `Element` usually posts messages on the bus provided by the parent -container using `ElementExt::post_message`. +container using `Element::post_message`. Create a new application-typed message. GStreamer will never create these messages; they are a gift from us to you. Enjoy. @@ -8487,7 +8720,7 @@ floating reference. Be aware that functions such as `GstBinExt::add` and `ElementExt::add_pad` take ownership of the floating reference. In contrast to `gobject::Object` instances, `Object` adds a name property. The functions -`GstObjectExt::set_name` and `GstObjectExt::get_name` are used to set/get the name +`Object::set_name` and `GstObjectExt::get_name` are used to set/get the name of the object. ## controlled properties @@ -8908,6 +9141,14 @@ property, we don't emit `gobject::Object::notify` and `Object::deep-notify` signals due to locking issues. In some cases one can use `Bin::element-added` or `Bin::element-removed` signals on the parent to achieve a similar effect. + +The standard flags that an gstobject may have. + +the object is expected to stay alive even +after `gst_deinit` has been called and so should be ignored by leak +detection tools. (Since: 1.10) + +subclasses can add additional flags starting from this flag A `Element` is linked to other elements via "pads", which are extremely light-weight generic link points. @@ -10138,6 +10379,81 @@ direction is unknown. the pad is a source pad. the pad is a sink pad. + +Pad state flags + +is dataflow on a pad blocked + +is pad flushing + +is pad in EOS state + +is pad currently blocking on a buffer or event + +ensure that there is a parent object before calling + into the pad callbacks. + +the pad should be reconfigured/renegotiated. + The flag has to be unset manually after + reconfiguration happened. + +the pad has pending events + +the pad is using fixed caps. This means that + once the caps are set on the pad, the default caps query function + will only return those caps. + +the default event and query handler will forward + all events and queries to the internally linked pads + instead of discarding them. + +the default query handler will forward + allocation queries to the internally linked pads + instead of discarding them. + +the default query handler will forward + scheduling queries to the internally linked pads + instead of discarding them. + +the default accept-caps handler will check + it the caps intersect the query-caps result instead + of checking for a subset. This is interesting for + parsers that can accept incompletely specified caps. + +the default accept-caps handler will use + the template pad caps instead of query caps to + compare with the accept caps. Use this in combination + with `PadFlags::AcceptIntersect`. (Since: 1.6) + +offset to define more flags + +The amount of checking to be done when linking pads. `PadLinkCheck::Caps` +and `PadLinkCheck::TemplateCaps` are mutually exclusive. If both are +specified, expensive but safe `PadLinkCheck::Caps` are performed. + +> Only disable some of the checks if you are 100% certain you know the link +> will not fail because of hierarchy/caps compatibility failures. If uncertain, +> use the default checks (`PadLinkCheck::Default`) or the regular methods +> for linking the pads. + +Don't check hierarchy or caps compatibility. + +Check the pads have same parents/grandparents. + Could be omitted if it is already known that the two elements that own the + pads are in the same bin. + +Check if the pads are compatible by using + their template caps. This is much faster than `PadLinkCheck::Caps`, but + would be unsafe e.g. if one pad has `GST_CAPS_ANY`. + +Check if the pads are compatible by comparing the + caps returned by `PadExt::query_caps`. + +Disables pushing a reconfigure event when pads are + linked. + +The default checks done when linking + pads (i.e. the ones used by `Pad::link`). Result values from gst_pad_link and friends. @@ -10201,6 +10517,57 @@ Data has been handled in the probe and will not be `GST_PAD_PROBE_INFO_FLOW_RETURN`() accessor. Note that the resulting query must contain valid entries. Since: 1.6 + +The different probing types that can occur. When either one of +`PadProbeType::Idle` or `PadProbeType::Block` is used, the probe will be a +blocking probe. + +invalid probe type + +probe idle pads and block while the callback is called + +probe and block pads + +probe buffers + +probe buffer lists + +probe downstream events + +probe upstream events + +probe flush events. This probe has to be + explicitly enabled and is not included in the + @`PadProbeType::EventDownstream` or + @`PadProbeType::EventUpstream` probe types. + +probe downstream queries + +probe upstream queries + +probe push + +probe pull + +probe and block at the next opportunity, at data flow or when idle + +probe downstream data (buffers, buffer lists, and events) + +probe upstream data (events) + +probe upstream and downstream data (buffers, buffer lists, and events) + +probe and block downstream data (buffers, buffer lists, and events) + +probe and block upstream data (events) + +probe upstream and downstream events + +probe upstream and downstream queries + +probe upstream events and queries and downstream buffers, buffer lists, events and queries + +probe push and pull Padtemplates describe the possible media types a pad or an elementfactory can handle. This allows for both inspection of handled types before loading the @@ -10323,10 +10690,30 @@ Gets the capabilities of the pad template. the `Caps` of the pad template. Unref after usage. + +See `PadTemplate::set_documentation_caps`. + +Feature: `v1_18` + + +# Returns + +The caps to document. For convenience, this will return + `PadTemplate::get_caps` when no documentation caps were set. Emit the pad-created signal for this template when created by this pad. ## `pad` the `Pad` that created it + +Certain elements will dynamically construct the caps of their +pad templates. In order not to let environment-specific information +into the documentation, element authors should use this method to +expose "stable" caps to the reader. + +Feature: `v1_18` + +## `caps` +the documented capabilities This signal is fired when an element creates a pad from this template. ## `pad` @@ -10372,6 +10759,9 @@ a newly-allocated parse context. Free Copies the `self`. +Feature: `v1_12_1` + + # Returns A copied `ParseContext` @@ -10405,6 +10795,21 @@ An empty bin was specified. An empty description was specified A delayed link did not get resolved. + +Parsing options. + +Do not use any special parsing options. + +Always return `None` when an error occurs + (default behaviour is to return partially constructed bins or elements + in some cases) + +If a bin only has a single element, + just return the element. + +If more than one toplevel element is described + by the pipeline description string, put them in a `Bin` instead of a + `Pipeline`. (Since: 1.10) A `Pipeline` is a special `Bin` used as the toplevel container for the filter graph. The `Pipeline` will manage the selection and @@ -10618,6 +11023,12 @@ see `PipelineExt::set_delay` for more information on this option. Latency to configure on the pipeline. See `PipelineExt::set_latency`. Latency to configure on the pipeline. See `PipelineExt::set_latency`. + +Pipeline flags + +this pipeline works with a fixed clock + +offset to define more flags GStreamer is extensible, so `Element` instances can be loaded at runtime. A plugin system can provide one or more of the basic GStreamer @@ -10895,6 +11306,35 @@ the `self`. The cache is flushed every time the registry is rebuilt. ## `cache_data` a structure containing the data to cache + + +Ignore enum members when generating + the plugins cache. This is useful if the members of the enum are generated + dynamically, in order not to expose incorrect documentation to the end user. + +Feature: `v1_18` + + +Flags used in connection with `Plugin::add_dependency`. + +no special flags + +recurse into subdirectories + +use paths + argument only if none of the environment variables is set + +interpret + filename argument as filter suffix and check all matching files in + the directory + +interpret + filename argument as filter prefix and check all matching files in + the directory. Since: 1.8. + +interpret + non-absolute paths as relative to the main executable directory. Since + 1.14. The plugin loading errors @@ -11010,6 +11450,12 @@ Specifies a rank for a plugin feature, so that autoplugging uses the most appropriate feature. ## `rank` rank value - higher number means more priority rank + +The plugin loading state + +Temporarily loaded plugins + +The plugin won't be scanned (again) This interface offers methods to query and manipulate parameter preset sets. A preset is a bunch of property settings, together with meta data and a name. @@ -12661,6 +13107,118 @@ A `Segment` Decreases the refcount of the sample. If the refcount reaches 0, the sample will be freed. + +The different scheduling flags. + +if seeking is possible + +if sequential access is recommended + +if bandwidth is limited and buffering possible (since 1.2) + +Flags to be used with `Element::seek` or `Event::new_seek`. All flags +can be used together. + +A non flushing seek might take some time to perform as the currently +playing data in the pipeline will not be cleared. + +An accurate seek might be slower for formats that don't have any indexes +or timestamp markers in the stream. Specifying this flag might require a +complete scan of the file in those cases. + +When performing a segment seek: after the playback of the segment completes, +no EOS will be emitted by the element that performed the seek, but a +`MessageType::SegmentDone` message will be posted on the bus by the element. +When this message is posted, it is possible to send a new seek event to +continue playback. With this seek method it is possible to perform seamless +looping or simple linear editing. + +When only changing the playback rate and not the direction, the +`SeekFlags::InstantRateChange` flag can be used for a non-flushing seek +to signal that the rate change should be applied immediately. This requires +special support in the seek handlers (e.g. demuxers) and any elements +synchronizing to the clock, and in general can't work in all cases (for example +UDP streaming where the delivery rate is controlled by a remote server). The +instant-rate-change mode supports changing the trickmode-related GST_SEEK_ flags, +but can't be used in conjunction with other seek flags that affect the new +playback position - as the playback position will not be changing. + +When doing fast forward (rate > 1.0) or fast reverse (rate < -1.0) trickmode +playback, the `SeekFlags::Trickmode` flag can be used to instruct decoders +and demuxers to adjust the playback rate by skipping frames. This can improve +performance and decrease CPU usage because not all frames need to be decoded. + +Beyond that, the `SeekFlags::TrickmodeKeyUnits` flag can be used to +request that decoders skip all frames except key units, and +`SeekFlags::TrickmodeNoAudio` flags can be used to request that audio +decoders do no decoding at all, and simple output silence. + +The `SeekFlags::SnapBefore` flag can be used to snap to the previous +relevant location, and the `SeekFlags::SnapAfter` flag can be used to +select the next relevant location. If `SeekFlags::KeyUnit` is specified, +the relevant location is a keyframe. If both flags are specified, the nearest +of these locations will be selected. If none are specified, the implementation is +free to select whichever it wants. + +The before and after here are in running time, so when playing backwards, +the next location refers to the one that will played in next, and not the +one that is located after in the actual source stream. + +Also see part-seeking.txt in the GStreamer design documentation for more +details on the meaning of these flags and the behaviour expected of +elements that handle them. + +no flag + +flush pipeline + +accurate position is requested, this might + be considerably slower for some formats. + +seek to the nearest keyframe. This might be + faster but less accurate. + +perform a segment seek. + +when doing fast forward or fast reverse playback, allow + elements to skip frames instead of generating all + frames. (Since: 1.6) + +Deprecated backward compatibility flag, replaced + by `SeekFlags::Trickmode` + +go to a location before the requested position, + if `SeekFlags::KeyUnit` this means the keyframe at or before + the requested position the one at or before the seek target. + +go to a location after the requested position, + if `SeekFlags::KeyUnit` this means the keyframe at of after the + requested position. + +go to a position near the requested position, + if `SeekFlags::KeyUnit` this means the keyframe closest + to the requested position, if both keyframes are at an equal + distance, behaves like `SeekFlags::SnapBefore`. + +when doing fast forward or fast reverse + playback, request that elements only decode keyframes + and skip all other content, for formats that have + keyframes. (Since: 1.6) + +when doing fast forward or fast reverse + playback, request that audio decoder elements skip + decoding and output only gap events or silence. (Since: 1.6) + +When doing fast forward or fast reverse + playback, request that elements only decode keyframes and + forward predicted frames and skip all other content (for example + B-Frames), for formats that have keyframes and forward predicted + frames. (Since: 1.18) + +Signals that a rate change should be + applied immediately. Only valid if start/stop position + are GST_CLOCK_TIME_NONE, the playback direction does not change + and the seek is not flushing. (Since: 1.18) The different types of seek events. When constructing a seek event with `Event::new_seek` or when doing gst_segment_do_seek (). @@ -13043,6 +13601,42 @@ result stream-time # Returns a 1 or -1 on success, 0 on failure. + +Flags for the GstSegment structure. Currently mapped to the corresponding +values of the seek flags. + +no flags + +reset the pipeline running_time to the segment + running_time + +perform skip playback (Since: 1.6) + +Deprecated backward compatibility flag, replaced + by `SegmentFlags::Trickmode` + +send SEGMENT_DONE instead of EOS + +Decode only keyframes, where + possible (Since: 1.6) + +Decode only keyframes or forward + predicted frames, where possible (Since: 1.18) + +Do not decode any audio, where + possible (Since: 1.6) + + +Try to retrieve the minimum information + available, which may be none on some platforms + (Since: 1.18) + +Try to retrieve as much information as possible, + including source information when getting the + stack trace + +Feature: `v1_12` + The possible states an element can be in. States can be changed using `Element::set_state` and checked using `Element::get_state`. @@ -13395,6 +13989,23 @@ used when the stream is encrypted and can't be decrypted because no suitable key is available. the number of stream error types. + + +This stream has no special attributes + +This stream is a sparse stream (e.g. a subtitle + stream), data may flow only in irregular intervals with large gaps in + between. + +This stream should be selected by default. This + flag may be used by demuxers to signal that a stream should be selected + by default in a playback scenario. + +This stream should not be selected by default. + This flag may be used by demuxers to signal that a stream should not + be selected by default in a playback scenario, but only if explicitly + selected by the user (e.g. an audio track for the hard of hearing or + a director's commentary track). The type of a `MessageType::StreamStatus`. The stream status messages inform the application of new streaming threads and their status. @@ -13412,23 +14023,44 @@ a thread is started a thread is paused a thread is stopped + +`StreamType` describes a high level classification set for +flows of data in `Stream` objects. + +Note that this is a flag, and therefore users should not assume it +will be a single value. Do not use the equality operator for checking +whether a stream is of a certain type. + +The stream is of unknown (unclassified) type. + +The stream is of audio data + +The stream carries video data + +The stream is a muxed container type + +The stream contains subtitle / subpicture data. + +Feature: `v1_10` + -A `Structure` is a collection of key/value pairs. The keys are expressed -as GQuarks and the values can be of any GType. +A `Structure` is a collection of key/value pairs. The keys are expressed as +GQuarks and the values can be of any GType. In addition to the key/value pairs, a `Structure` also has a name. The name -starts with a letter and can be filled by letters, numbers and any of "/-_.:". +starts with a letter and can be filled by letters, numbers and any of +"/-_.:". -`Structure` is used by various GStreamer subsystems to store information -in a flexible and extensible way. A `Structure` does not have a refcount +`Structure` is used by various GStreamer subsystems to store information in +a flexible and extensible way. A `Structure` does not have a refcount because it usually is part of a higher level object such as `Caps`, `Message`, `Event`, `Query`. It provides a means to enforce mutability using the refcount of the parent with the `Structure::set_parent_refcount` method. A `Structure` can be created with `Structure::new_empty` or -`Structure::new`, which both take a name and an optional set of -key/value pairs along with the types of the values. +`Structure::new`, which both take a name and an optional set of key/value +pairs along with the types of the values. Field values can be changed with `Structure::set_value` or `Structure::set`. @@ -13439,14 +14071,78 @@ convenient gst_structure_get_*() functions. Fields can be removed with `Structure::remove_field` or `Structure::remove_fields`. -Strings in structures must be ASCII or UTF-8 encoded. Other encodings are -not allowed. Strings may be `None` however. +Strings in structures must be ASCII or UTF-8 encoded. Other encodings are not +allowed. Strings may be `None` however. -Be aware that the current `Caps` / `Structure` serialization into string -has limited support for nested `Caps` / `Structure` fields. It can only -support one level of nesting. Using more levels will lead to unexpected -behavior when using serialization features, such as `Caps::to_string` or -`gst_value_serialize` and their counterparts. +## The serialization format + +GstStructure serialization format serialize the GstStructure name, +keys/GType/values in a comma separated list with the structure name as first +field without value followed by separated key/value pairs in the form +`key=value`, for example: + +``` +a-structure, key=value +```` + +The values type will be inferred if not explicitly specified with the +`(GTypeName)value` syntax, for example the following struct will have one +field called 'is-string' which has the string 'true' as a value: + +``` +a-struct, field-is-string=(string)true, field-is-boolean=true +``` + +*Note*: without specifying `(string), `field-is-string` type would have been +inferred as boolean. + +*Note*: we specified `(string)` as a type even if `gchararray` is the actual +GType name as for convenience some well known types have been aliased or +abbreviated. + +To avoid specifying the type, you can give some hints to the "type system". +For example to specify a value as a double, you should add a decimal (ie. `1` +is an `int` while `1.0` is a `double`). + +*Note*: when a structure is serialized with `Structure::to_string`, all +values are explicitly typed. + +Some types have special delimiters: + +- [GstValueArray](GST_TYPE_ARRAY) are inside curly brackets (`{` and `}`). + For example `a-structure, array={1, 2, 3}` +- Ranges are inside brackets (`[` and `]`). For example `a-structure, + range=[1, 6, 2]` 1 being the min value, 6 the maximum and 2 the step. To + specify a `GST_TYPE_INT64_RANGE` you need to explicitly specify it like: + `a-structure, a-int64-range=(gint64) [1, 5]` +- [GstValueList](GST_TYPE_LIST) are inside "less and greater than" (`<` and + `>`). For example `a-structure, list=<1, 2, 3> + +Structures are delimited either by a null character `\0` or a semicolumn `;` +the latter allowing to store multiple structures in the same string (see +#GstCaps). + +Quotes are used as "default" delimiters and can be used around any types that +don't use other delimiters (for example `a-struct, i=(int)"1"`). They are use +to allow adding spaces or special characters (such as delimiters, +semicolumns, etc..) inside strings and you can use backslashes `\` to escape +characters inside them, for example: + +``` +a-struct, special="\"{[(;)]}\" can be used inside quotes" +``` + +They also allow for nested structure, such as: + +``` +a-struct, nested=(GstStructure)"nested-struct, nested=true" +``` + +> *Note*: Be aware that the current #GstCaps / #GstStructure serialization +> into string has limited support for nested #GstCaps / #GstStructure fields. +> It can only support one level of nesting. Using more levels will lead to +> unexpected behavior when using serialization features, such as +> gst_caps_to_string() or gst_value_serialize() and their counterparts. Creates a `Structure` from a string representation. If end is not `None`, a pointer to the place inside the given string @@ -13687,6 +14383,9 @@ This is useful in language bindings where unknown `gobject::Value` types are not supported. This function will convert the `GST_TYPE_ARRAY` into a newly allocated `gobject::ValueArray` and return it through `array`. Be aware that this is slower then getting the `gobject::Value` directly. + +Feature: `v1_12` + ## `fieldname` the name of a field ## `array`