| /* GStreamer | |
| * Copyright (C) <2005> Philippe Khalaf <burger@speedy.org> | |
| * Copyright (C) <2005> Nokia Corporation <kai.vehmanen@nokia.com> | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Library General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Library General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Library General Public | |
| * License along with this library; if not, write to the | |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
| * Boston, MA 02110-1301, USA. | |
| */ | |
| /** | |
| * SECTION:gstrtpbasedepayload | |
| * @title: GstRTPBaseDepayload | |
| * @short_description: Base class for RTP depayloader | |
| * | |
| * Provides a base class for RTP depayloaders | |
| * | |
| * In order to handle RTP header extensions correctly if the | |
| * depayloader aggregates multiple RTP packet payloads into one output | |
| * buffer this class provides the function | |
| * gst_rtp_base_depayload_set_aggregate_hdrext_enabled(). If the | |
| * aggregation is enabled the virtual functions | |
| * @GstRTPBaseDepayload.process or | |
| * @GstRTPBaseDepayload.process_rtp_packet must tell the base class | |
| * what happens to the current RTP packet. By default the base class | |
| * assumes that the packet payload is used with the next output | |
| * buffer. | |
| * | |
| * If the RTP packet will not be used with an output buffer | |
| * gst_rtp_base_depayload_dropped() must be called. A typical | |
| * situation would be if we are waiting for a keyframe. | |
| * | |
| * If the RTP packet will be used but not with the current output | |
| * buffer but with the next one gst_rtp_base_depayload_delayed() must | |
| * be called. This may happen if the current RTP packet signals the | |
| * start of a new output buffer and the currently processed output | |
| * buffer will be pushed first. The undelay happens implicitly once | |
| * the current buffer has been pushed or | |
| * gst_rtp_base_depayload_flush() has been called. | |
| * | |
| * If gst_rtp_base_depayload_flush() is called all RTP packets that | |
| * have not been dropped since the last output buffer are dropped, | |
| * e.g. if an output buffer is discarded due to malformed data. This | |
| * may or may not include the current RTP packet depending on the 2nd | |
| * parameter @keep_current. | |
| * | |
| * Be aware that in case gst_rtp_base_depayload_push_list() is used | |
| * each buffer will see the same list of RTP header extensions. | |
| */ | |
| #ifdef HAVE_CONFIG_H | |
| #include "config.h" | |
| #endif | |
| #include "gstrtpbasedepayload.h" | |
| #include "gstrtpmeta.h" | |
| #include "gstrtphdrext.h" | |
| GST_DEBUG_CATEGORY_STATIC (rtpbasedepayload_debug); | |
| #define GST_CAT_DEFAULT (rtpbasedepayload_debug) | |
| static GstStaticCaps ntp_reference_timestamp_caps = | |
| GST_STATIC_CAPS ("timestamp/x-ntp"); | |
| struct _GstRTPBaseDepayloadPrivate | |
| { | |
| GstClockTime npt_start; | |
| GstClockTime npt_stop; | |
| gdouble play_speed; | |
| gdouble play_scale; | |
| guint clock_base; | |
| gboolean onvif_mode; | |
| gboolean discont; | |
| GstClockTime pts; | |
| GstClockTime dts; | |
| GstClockTime duration; | |
| GstClockTime ref_ts; | |
| guint32 last_ssrc; | |
| guint32 last_seqnum; | |
| guint32 last_rtptime; | |
| guint32 next_seqnum; | |
| gint max_reorder; | |
| gboolean auto_hdr_ext; | |
| gboolean negotiated; | |
| GstCaps *last_caps; | |
| GstEvent *segment_event; | |
| guint32 segment_seqnum; /* Note: this is a GstEvent seqnum */ | |
| gboolean source_info; | |
| GstBuffer *input_buffer; | |
| GstFlowReturn process_flow_ret; | |
| /* array of GstRTPHeaderExtension's * */ | |
| GPtrArray *header_exts; | |
| /* maintain buffer list for header extensions read() */ | |
| gboolean hdrext_aggregate; | |
| gboolean hdrext_seen; | |
| GstBufferList *hdrext_buffers; | |
| GstBuffer *hdrext_delayed; | |
| GstBuffer *hdrext_outbuf; | |
| gboolean hdrext_read_result; | |
| }; | |
| /* Filter signals and args */ | |
| enum | |
| { | |
| SIGNAL_0, | |
| SIGNAL_REQUEST_EXTENSION, | |
| SIGNAL_ADD_EXTENSION, | |
| SIGNAL_CLEAR_EXTENSIONS, | |
| LAST_SIGNAL | |
| }; | |
| static guint gst_rtp_base_depayload_signals[LAST_SIGNAL] = { 0 }; | |
| #define DEFAULT_SOURCE_INFO FALSE | |
| #define DEFAULT_MAX_REORDER 100 | |
| #define DEFAULT_AUTO_HEADER_EXTENSION TRUE | |
| enum | |
| { | |
| PROP_0, | |
| PROP_STATS, | |
| PROP_SOURCE_INFO, | |
| PROP_MAX_REORDER, | |
| PROP_AUTO_HEADER_EXTENSION, | |
| PROP_EXTENSIONS, | |
| PROP_LAST | |
| }; | |
| static GParamSpec *gst_rtp_base_depayload_extensions_pspec; | |
| static void gst_rtp_base_depayload_finalize (GObject * object); | |
| static void gst_rtp_base_depayload_set_property (GObject * object, | |
| guint prop_id, const GValue * value, GParamSpec * pspec); | |
| static void gst_rtp_base_depayload_get_property (GObject * object, | |
| guint prop_id, GValue * value, GParamSpec * pspec); | |
| static GstFlowReturn gst_rtp_base_depayload_chain (GstPad * pad, | |
| GstObject * parent, GstBuffer * in); | |
| static GstFlowReturn gst_rtp_base_depayload_chain_list (GstPad * pad, | |
| GstObject * parent, GstBufferList * list); | |
| static gboolean gst_rtp_base_depayload_handle_sink_event (GstPad * pad, | |
| GstObject * parent, GstEvent * event); | |
| static GstStateChangeReturn gst_rtp_base_depayload_change_state (GstElement * | |
| element, GstStateChange transition); | |
| static gboolean gst_rtp_base_depayload_packet_lost (GstRTPBaseDepayload * | |
| filter, GstEvent * event); | |
| static gboolean gst_rtp_base_depayload_handle_event (GstRTPBaseDepayload * | |
| filter, GstEvent * event); | |
| static GstElementClass *parent_class = NULL; | |
| static gint private_offset = 0; | |
| static void gst_rtp_base_depayload_class_init (GstRTPBaseDepayloadClass * | |
| klass); | |
| static void gst_rtp_base_depayload_init (GstRTPBaseDepayload * rtpbasepayload, | |
| GstRTPBaseDepayloadClass * klass); | |
| static GstEvent *create_segment_event (GstRTPBaseDepayload * filter, | |
| guint rtptime, GstClockTime position); | |
| static void gst_rtp_base_depayload_add_extension (GstRTPBaseDepayload * | |
| rtpbasepayload, GstRTPHeaderExtension * ext); | |
| static void gst_rtp_base_depayload_clear_extensions (GstRTPBaseDepayload * | |
| rtpbasepayload); | |
| static gboolean gst_rtp_base_depayload_operate_hdrext_buffer (GstBuffer ** | |
| buffer, guint idx, gpointer depayloader); | |
| static void gst_rtp_base_depayload_reset_hdrext_buffers (GstRTPBaseDepayload * | |
| rtpbasepayload); | |
| GType | |
| gst_rtp_base_depayload_get_type (void) | |
| { | |
| static GType rtp_base_depayload_type = 0; | |
| if (g_once_init_enter ((gsize *) & rtp_base_depayload_type)) { | |
| static const GTypeInfo rtp_base_depayload_info = { | |
| sizeof (GstRTPBaseDepayloadClass), | |
| NULL, | |
| NULL, | |
| (GClassInitFunc) gst_rtp_base_depayload_class_init, | |
| NULL, | |
| NULL, | |
| sizeof (GstRTPBaseDepayload), | |
| 0, | |
| (GInstanceInitFunc) gst_rtp_base_depayload_init, | |
| }; | |
| GType _type; | |
| _type = g_type_register_static (GST_TYPE_ELEMENT, "GstRTPBaseDepayload", | |
| &rtp_base_depayload_info, G_TYPE_FLAG_ABSTRACT); | |
| private_offset = | |
| g_type_add_instance_private (_type, | |
| sizeof (GstRTPBaseDepayloadPrivate)); | |
| g_once_init_leave ((gsize *) & rtp_base_depayload_type, _type); | |
| } | |
| return rtp_base_depayload_type; | |
| } | |
| static inline GstRTPBaseDepayloadPrivate * | |
| gst_rtp_base_depayload_get_instance_private (GstRTPBaseDepayload * self) | |
| { | |
| return (G_STRUCT_MEMBER_P (self, private_offset)); | |
| } | |
| static GstRTPHeaderExtension * | |
| gst_rtp_base_depayload_request_extension_default (GstRTPBaseDepayload * | |
| depayload, guint ext_id, const gchar * uri) | |
| { | |
| GstRTPHeaderExtension *ext = NULL; | |
| if (!depayload->priv->auto_hdr_ext) | |
| return NULL; | |
| ext = gst_rtp_header_extension_create_from_uri (uri); | |
| if (ext) { | |
| GST_DEBUG_OBJECT (depayload, | |
| "Automatically enabled extension %s for uri \'%s\'", | |
| GST_ELEMENT_NAME (ext), uri); | |
| gst_rtp_header_extension_set_id (ext, ext_id); | |
| } else { | |
| GST_DEBUG_OBJECT (depayload, | |
| "Didn't find any extension implementing uri \'%s\'", uri); | |
| } | |
| return ext; | |
| } | |
| static gboolean | |
| extension_accumulator (GSignalInvocationHint * ihint, | |
| GValue * return_accu, const GValue * handler_return, gpointer data) | |
| { | |
| gpointer ext; | |
| /* Call default handler if user callback didn't create the extension */ | |
| ext = g_value_get_object (handler_return); | |
| if (!ext) | |
| return TRUE; | |
| g_value_set_object (return_accu, ext); | |
| return FALSE; | |
| } | |
| static void | |
| gst_rtp_base_depayload_class_init (GstRTPBaseDepayloadClass * klass) | |
| { | |
| GObjectClass *gobject_class; | |
| GstElementClass *gstelement_class; | |
| gobject_class = G_OBJECT_CLASS (klass); | |
| gstelement_class = (GstElementClass *) klass; | |
| parent_class = g_type_class_peek_parent (klass); | |
| if (private_offset != 0) | |
| g_type_class_adjust_private_offset (klass, &private_offset); | |
| gobject_class->finalize = gst_rtp_base_depayload_finalize; | |
| gobject_class->set_property = gst_rtp_base_depayload_set_property; | |
| gobject_class->get_property = gst_rtp_base_depayload_get_property; | |
| /** | |
| * GstRTPBaseDepayload:stats: | |
| * | |
| * Various depayloader statistics retrieved atomically (and are therefore | |
| * synchroized with each other). This property return a GstStructure named | |
| * application/x-rtp-depayload-stats containing the following fields relating to | |
| * the last processed buffer and current state of the stream being depayloaded: | |
| * | |
| * * `clock-rate`: #G_TYPE_UINT, clock-rate of the stream | |
| * * `npt-start`: #G_TYPE_UINT64, time of playback start | |
| * * `npt-stop`: #G_TYPE_UINT64, time of playback stop | |
| * * `play-speed`: #G_TYPE_DOUBLE, the playback speed | |
| * * `play-scale`: #G_TYPE_DOUBLE, the playback scale | |
| * * `running-time-dts`: #G_TYPE_UINT64, the last running-time of the | |
| * last DTS | |
| * * `running-time-pts`: #G_TYPE_UINT64, the last running-time of the | |
| * last PTS | |
| * * `seqnum`: #G_TYPE_UINT, the last seen seqnum | |
| * * `timestamp`: #G_TYPE_UINT, the last seen RTP timestamp | |
| **/ | |
| g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_STATS, | |
| g_param_spec_boxed ("stats", "Statistics", "Various statistics", | |
| GST_TYPE_STRUCTURE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); | |
| /** | |
| * GstRTPBaseDepayload:source-info: | |
| * | |
| * Add RTP source information found in RTP header as meta to output buffer. | |
| * | |
| * Since: 1.16 | |
| **/ | |
| g_object_class_install_property (gobject_class, PROP_SOURCE_INFO, | |
| g_param_spec_boolean ("source-info", "RTP source information", | |
| "Add RTP source information as buffer meta", | |
| DEFAULT_SOURCE_INFO, G_PARAM_READWRITE)); | |
| /** | |
| * GstRTPBaseDepayload:max-reorder: | |
| * | |
| * Max seqnum reorder before the sender is assumed to have restarted. | |
| * | |
| * When max-reorder is set to 0 all reordered/duplicate packets are | |
| * considered coming from a restarted sender. | |
| * | |
| * Since: 1.18 | |
| **/ | |
| g_object_class_install_property (gobject_class, PROP_MAX_REORDER, | |
| g_param_spec_int ("max-reorder", "Max Reorder", | |
| "Max seqnum reorder before assuming sender has restarted", | |
| 0, G_MAXINT, DEFAULT_MAX_REORDER, G_PARAM_READWRITE)); | |
| /** | |
| * GstRTPBaseDepayload:auto-header-extension: | |
| * | |
| * If enabled, the depayloader will automatically try to enable all the | |
| * RTP header extensions provided in the sink caps, saving the application | |
| * the need to handle these extensions manually using the | |
| * GstRTPBaseDepayload::request-extension: signal. | |
| * | |
| * Since: 1.20 | |
| */ | |
| g_object_class_install_property (G_OBJECT_CLASS (klass), | |
| PROP_AUTO_HEADER_EXTENSION, g_param_spec_boolean ("auto-header-extension", | |
| "Automatic RTP header extension", | |
| "Whether RTP header extensions should be automatically enabled, if an implementation is available", | |
| DEFAULT_AUTO_HEADER_EXTENSION, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); | |
| /** | |
| * GstRTPBaseDepayload::request-extension: | |
| * @object: the #GstRTPBaseDepayload | |
| * @ext_id: the extension id being requested | |
| * @ext_uri: (nullable): the extension URI being requested | |
| * | |
| * The returned @ext must be configured with the correct @ext_id and with the | |
| * necessary attributes as required by the extension implementation. | |
| * | |
| * Returns: (transfer full) (nullable): the #GstRTPHeaderExtension for @ext_id, or %NULL | |
| * | |
| * Since: 1.20 | |
| */ | |
| gst_rtp_base_depayload_signals[SIGNAL_REQUEST_EXTENSION] = | |
| g_signal_new_class_handler ("request-extension", | |
| G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, | |
| G_CALLBACK (gst_rtp_base_depayload_request_extension_default), | |
| extension_accumulator, NULL, NULL, | |
| GST_TYPE_RTP_HEADER_EXTENSION, 2, G_TYPE_UINT, G_TYPE_STRING); | |
| /** | |
| * GstRTPBaseDepayload::add-extension: | |
| * @object: the #GstRTPBaseDepayload | |
| * @ext: (transfer full): the #GstRTPHeaderExtension | |
| * | |
| * Add @ext as an extension for reading part of an RTP header extension from | |
| * incoming RTP packets. | |
| * | |
| * Since: 1.20 | |
| */ | |
| gst_rtp_base_depayload_signals[SIGNAL_ADD_EXTENSION] = | |
| g_signal_new_class_handler ("add-extension", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, | |
| G_CALLBACK (gst_rtp_base_depayload_add_extension), NULL, NULL, NULL, | |
| G_TYPE_NONE, 1, GST_TYPE_RTP_HEADER_EXTENSION); | |
| /** | |
| * GstRTPBaseDepayload::clear-extensions: | |
| * @object: the #GstRTPBaseDepayload | |
| * | |
| * Clear all RTP header extensions used by this depayloader. | |
| * | |
| * Since: 1.20 | |
| */ | |
| gst_rtp_base_depayload_signals[SIGNAL_CLEAR_EXTENSIONS] = | |
| g_signal_new_class_handler ("clear-extensions", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, | |
| G_CALLBACK (gst_rtp_base_depayload_clear_extensions), NULL, NULL, NULL, | |
| G_TYPE_NONE, 0); | |
| gst_rtp_base_depayload_extensions_pspec = gst_param_spec_array ("extensions", | |
| "RTP header extensions", | |
| "A list of already enabled RTP header extensions", | |
| g_param_spec_object ("extension", "RTP header extension", | |
| "An already enabled RTP extension", GST_TYPE_RTP_HEADER_EXTENSION, | |
| G_PARAM_READABLE | G_PARAM_STATIC_STRINGS), | |
| G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); | |
| /** | |
| * GstRTPBaseDepayload:extensions: | |
| * | |
| * A list of already enabled RTP header extensions. This may be useful for finding | |
| * out which extensions are already enabled (with add-extension signal) and picking a non-conflicting | |
| * ID for a new extension that needs to be added on top of the existing ones. | |
| * | |
| * Note that the value returned by reading this property is not dynamically updated when the set of | |
| * enabled extensions changes by any of existing action signals. Rather, it represents the current state | |
| * at the time the property is read. | |
| * | |
| * Dynamic updates of this property can be received by subscribing to its corresponding "notify" signal, i.e. | |
| * "notify::extensions". | |
| * | |
| * Since: 1.24 | |
| */ | |
| g_object_class_install_property (G_OBJECT_CLASS (klass), | |
| PROP_EXTENSIONS, gst_rtp_base_depayload_extensions_pspec); | |
| gstelement_class->change_state = gst_rtp_base_depayload_change_state; | |
| klass->packet_lost = gst_rtp_base_depayload_packet_lost; | |
| klass->handle_event = gst_rtp_base_depayload_handle_event; | |
| GST_DEBUG_CATEGORY_INIT (rtpbasedepayload_debug, "rtpbasedepayload", 0, | |
| "Base class for RTP Depayloaders"); | |
| } | |
| static void | |
| gst_rtp_base_depayload_init (GstRTPBaseDepayload * filter, | |
| GstRTPBaseDepayloadClass * klass) | |
| { | |
| GstPadTemplate *pad_template; | |
| GstRTPBaseDepayloadPrivate *priv; | |
| priv = gst_rtp_base_depayload_get_instance_private (filter); | |
| filter->priv = priv; | |
| GST_DEBUG_OBJECT (filter, "init"); | |
| pad_template = | |
| gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "sink"); | |
| g_return_if_fail (pad_template != NULL); | |
| filter->sinkpad = gst_pad_new_from_template (pad_template, "sink"); | |
| gst_pad_set_chain_function (filter->sinkpad, gst_rtp_base_depayload_chain); | |
| gst_pad_set_chain_list_function (filter->sinkpad, | |
| gst_rtp_base_depayload_chain_list); | |
| gst_pad_set_event_function (filter->sinkpad, | |
| gst_rtp_base_depayload_handle_sink_event); | |
| gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); | |
| pad_template = | |
| gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "src"); | |
| g_return_if_fail (pad_template != NULL); | |
| filter->srcpad = gst_pad_new_from_template (pad_template, "src"); | |
| gst_pad_use_fixed_caps (filter->srcpad); | |
| gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); | |
| priv->npt_start = 0; | |
| priv->npt_stop = -1; | |
| priv->play_speed = 1.0; | |
| priv->play_scale = 1.0; | |
| priv->clock_base = -1; | |
| priv->onvif_mode = FALSE; | |
| priv->dts = -1; | |
| priv->pts = -1; | |
| priv->duration = -1; | |
| priv->ref_ts = -1; | |
| priv->source_info = DEFAULT_SOURCE_INFO; | |
| priv->max_reorder = DEFAULT_MAX_REORDER; | |
| priv->auto_hdr_ext = DEFAULT_AUTO_HEADER_EXTENSION; | |
| priv->hdrext_aggregate = FALSE; | |
| priv->hdrext_seen = FALSE; | |
| gst_segment_init (&filter->segment, GST_FORMAT_UNDEFINED); | |
| priv->header_exts = | |
| g_ptr_array_new_with_free_func ((GDestroyNotify) gst_object_unref); | |
| priv->hdrext_buffers = gst_buffer_list_new (); | |
| } | |
| static void | |
| gst_rtp_base_depayload_finalize (GObject * object) | |
| { | |
| GstRTPBaseDepayload *rtpbasedepayload = GST_RTP_BASE_DEPAYLOAD (object); | |
| GstRTPBaseDepayloadPrivate *priv = rtpbasedepayload->priv; | |
| g_ptr_array_unref (rtpbasedepayload->priv->header_exts); | |
| gst_clear_buffer_list (&rtpbasedepayload->priv->hdrext_buffers); | |
| if (priv->hdrext_delayed) | |
| gst_buffer_unref (priv->hdrext_delayed); | |
| G_OBJECT_CLASS (parent_class)->finalize (object); | |
| } | |
| static void | |
| add_and_ref_item (GstRTPHeaderExtension * ext, GPtrArray * ret) | |
| { | |
| g_ptr_array_add (ret, gst_object_ref (ext)); | |
| } | |
| static void | |
| remove_item_from (GstRTPHeaderExtension * ext, GPtrArray * ret) | |
| { | |
| g_ptr_array_remove_fast (ret, ext); | |
| } | |
| static void | |
| add_item_to (GstRTPHeaderExtension * ext, GPtrArray * ret) | |
| { | |
| g_ptr_array_add (ret, ext); | |
| } | |
| static gboolean | |
| gst_rtp_base_depayload_setcaps (GstRTPBaseDepayload * filter, GstCaps * caps) | |
| { | |
| GstRTPBaseDepayloadClass *bclass; | |
| GstRTPBaseDepayloadPrivate *priv; | |
| gboolean res = TRUE; | |
| GstStructure *caps_struct; | |
| const GValue *value; | |
| priv = filter->priv; | |
| bclass = GST_RTP_BASE_DEPAYLOAD_GET_CLASS (filter); | |
| GST_DEBUG_OBJECT (filter, "Set caps %" GST_PTR_FORMAT, caps); | |
| if (priv->last_caps) { | |
| if (gst_caps_is_equal (priv->last_caps, caps)) { | |
| res = TRUE; | |
| goto caps_not_changed; | |
| } else { | |
| gst_caps_unref (priv->last_caps); | |
| priv->last_caps = NULL; | |
| } | |
| } | |
| caps_struct = gst_caps_get_structure (caps, 0); | |
| value = gst_structure_get_value (caps_struct, "onvif-mode"); | |
| if (value && G_VALUE_HOLDS_BOOLEAN (value)) | |
| priv->onvif_mode = g_value_get_boolean (value); | |
| else | |
| priv->onvif_mode = FALSE; | |
| GST_DEBUG_OBJECT (filter, "Onvif mode: %d", priv->onvif_mode); | |
| if (priv->onvif_mode) | |
| filter->need_newsegment = FALSE; | |
| /* get other values for newsegment */ | |
| value = gst_structure_get_value (caps_struct, "npt-start"); | |
| if (value && G_VALUE_HOLDS_UINT64 (value)) | |
| priv->npt_start = g_value_get_uint64 (value); | |
| else | |
| priv->npt_start = 0; | |
| GST_DEBUG_OBJECT (filter, "NPT start %" G_GUINT64_FORMAT, priv->npt_start); | |
| value = gst_structure_get_value (caps_struct, "npt-stop"); | |
| if (value && G_VALUE_HOLDS_UINT64 (value)) | |
| priv->npt_stop = g_value_get_uint64 (value); | |
| else | |
| priv->npt_stop = -1; | |
| GST_DEBUG_OBJECT (filter, "NPT stop %" G_GUINT64_FORMAT, priv->npt_stop); | |
| value = gst_structure_get_value (caps_struct, "play-speed"); | |
| if (value && G_VALUE_HOLDS_DOUBLE (value)) | |
| priv->play_speed = g_value_get_double (value); | |
| else | |
| priv->play_speed = 1.0; | |
| value = gst_structure_get_value (caps_struct, "play-scale"); | |
| if (value && G_VALUE_HOLDS_DOUBLE (value)) | |
| priv->play_scale = g_value_get_double (value); | |
| else | |
| priv->play_scale = 1.0; | |
| value = gst_structure_get_value (caps_struct, "clock-base"); | |
| if (value && G_VALUE_HOLDS_UINT (value)) | |
| priv->clock_base = g_value_get_uint (value); | |
| else | |
| priv->clock_base = -1; | |
| { | |
| /* ensure we have header extension implementations for the list in the | |
| * caps */ | |
| guint i, j, n_fields = gst_structure_n_fields (caps_struct); | |
| GPtrArray *header_exts = g_ptr_array_new_with_free_func (gst_object_unref); | |
| GPtrArray *to_add = g_ptr_array_new (); | |
| GPtrArray *to_remove = g_ptr_array_new (); | |
| GST_OBJECT_LOCK (filter); | |
| g_ptr_array_foreach (filter->priv->header_exts, | |
| (GFunc) add_and_ref_item, header_exts); | |
| GST_OBJECT_UNLOCK (filter); | |
| for (i = 0; i < n_fields; i++) { | |
| const gchar *field_name = gst_structure_nth_field_name (caps_struct, i); | |
| if (g_str_has_prefix (field_name, "extmap-")) { | |
| const GValue *val; | |
| const gchar *uri = NULL; | |
| gchar *nptr; | |
| guint ext_id; | |
| GstRTPHeaderExtension *ext = NULL; | |
| errno = 0; | |
| ext_id = g_ascii_strtoull (&field_name[strlen ("extmap-")], &nptr, 10); | |
| if (errno != 0 || (ext_id == 0 && field_name == nptr)) { | |
| GST_WARNING_OBJECT (filter, "could not parse id from %s", field_name); | |
| res = FALSE; | |
| goto ext_out; | |
| } | |
| val = gst_structure_get_value (caps_struct, field_name); | |
| if (G_VALUE_HOLDS_STRING (val)) { | |
| uri = g_value_get_string (val); | |
| } else if (GST_VALUE_HOLDS_ARRAY (val)) { | |
| /* the uri is the second value in the array */ | |
| const GValue *str = gst_value_array_get_value (val, 1); | |
| if (G_VALUE_HOLDS_STRING (str)) { | |
| uri = g_value_get_string (str); | |
| } | |
| } | |
| if (!uri) { | |
| GST_WARNING_OBJECT (filter, "could not get extmap uri for " | |
| "field %s", field_name); | |
| res = FALSE; | |
| goto ext_out; | |
| } | |
| /* try to find if this extension mapping already exists */ | |
| for (j = 0; j < header_exts->len; j++) { | |
| ext = g_ptr_array_index (header_exts, j); | |
| if (gst_rtp_header_extension_get_id (ext) == ext_id) { | |
| if (g_strcmp0 (uri, gst_rtp_header_extension_get_uri (ext)) == 0) { | |
| /* still matching, we're good, set attributes from caps in case | |
| * the caps have changed */ | |
| if (!gst_rtp_header_extension_set_attributes_from_caps (ext, | |
| caps)) { | |
| GST_WARNING_OBJECT (filter, | |
| "Failed to configure rtp header " "extension %" | |
| GST_PTR_FORMAT " attributes from caps %" GST_PTR_FORMAT, | |
| ext, caps); | |
| res = FALSE; | |
| goto ext_out; | |
| } | |
| break; | |
| } else { | |
| GST_DEBUG_OBJECT (filter, "extension id %u" | |
| "was replaced with a different extension uri " | |
| "original:\'%s' vs \'%s\'", ext_id, | |
| gst_rtp_header_extension_get_uri (ext), uri); | |
| g_ptr_array_add (to_remove, ext); | |
| ext = NULL; | |
| break; | |
| } | |
| } else { | |
| ext = NULL; | |
| } | |
| } | |
| /* if no extension, attempt to request one */ | |
| if (!ext) { | |
| GST_DEBUG_OBJECT (filter, "requesting extension for id %u" | |
| " and uri %s", ext_id, uri); | |
| g_signal_emit (filter, | |
| gst_rtp_base_depayload_signals[SIGNAL_REQUEST_EXTENSION], 0, | |
| ext_id, uri, &ext); | |
| GST_DEBUG_OBJECT (filter, "request returned extension %p \'%s\' " | |
| "for id %u and uri %s", ext, | |
| ext ? GST_OBJECT_NAME (ext) : "", ext_id, uri); | |
| /* We require the caller to set the appropriate extension if it's required */ | |
| if (ext && gst_rtp_header_extension_get_id (ext) != ext_id) { | |
| g_warning ("\'request-extension\' signal provided an rtp header " | |
| "extension for uri \'%s\' that does not match the requested " | |
| "extension id %u", uri, ext_id); | |
| gst_clear_object (&ext); | |
| } | |
| if (ext && !gst_rtp_header_extension_set_attributes_from_caps (ext, | |
| caps)) { | |
| GST_WARNING_OBJECT (filter, | |
| "Failed to configure rtp header " "extension %" | |
| GST_PTR_FORMAT " attributes from caps %" GST_PTR_FORMAT, | |
| ext, caps); | |
| res = FALSE; | |
| g_clear_object (&ext); | |
| goto ext_out; | |
| } | |
| if (ext) | |
| g_ptr_array_add (to_add, ext); | |
| } | |
| } | |
| } | |
| /* Note: we intentionally don't remove extensions that are not listed | |
| * in caps */ | |
| GST_OBJECT_LOCK (filter); | |
| g_ptr_array_foreach (to_remove, (GFunc) remove_item_from, | |
| filter->priv->header_exts); | |
| g_ptr_array_foreach (to_add, (GFunc) add_item_to, | |
| filter->priv->header_exts); | |
| GST_OBJECT_UNLOCK (filter); | |
| g_object_notify_by_pspec (G_OBJECT (filter), | |
| gst_rtp_base_depayload_extensions_pspec); | |
| ext_out: | |
| g_ptr_array_unref (to_add); | |
| g_ptr_array_unref (to_remove); | |
| g_ptr_array_unref (header_exts); | |
| if (!res) | |
| return res; | |
| } | |
| if (bclass->set_caps) { | |
| res = bclass->set_caps (filter, caps); | |
| if (!res) { | |
| GST_WARNING_OBJECT (filter, "Subclass rejected caps %" GST_PTR_FORMAT, | |
| caps); | |
| } | |
| } else { | |
| res = TRUE; | |
| } | |
| priv->negotiated = res; | |
| if (priv->negotiated) | |
| priv->last_caps = gst_caps_ref (caps); | |
| return res; | |
| caps_not_changed: | |
| { | |
| GST_DEBUG_OBJECT (filter, "Caps did not change"); | |
| return res; | |
| } | |
| } | |
| /* takes ownership of the input buffer */ | |
| static GstFlowReturn | |
| gst_rtp_base_depayload_handle_buffer (GstRTPBaseDepayload * filter, | |
| GstRTPBaseDepayloadClass * bclass, GstBuffer * in) | |
| { | |
| GstBuffer *(*process_rtp_packet_func) (GstRTPBaseDepayload * base, | |
| GstRTPBuffer * rtp_buffer); | |
| GstBuffer *(*process_func) (GstRTPBaseDepayload * base, GstBuffer * in); | |
| GstRTPBaseDepayloadPrivate *priv; | |
| GstBuffer *out_buf; | |
| guint32 ssrc; | |
| guint16 seqnum; | |
| guint32 rtptime; | |
| gboolean discont, buf_discont; | |
| gint gap; | |
| GstRTPBuffer rtp = { NULL }; | |
| GstReferenceTimestampMeta *meta; | |
| GstCaps *ref_caps; | |
| priv = filter->priv; | |
| priv->process_flow_ret = GST_FLOW_OK; | |
| process_func = bclass->process; | |
| process_rtp_packet_func = bclass->process_rtp_packet; | |
| /* we must have a setcaps first */ | |
| if (G_UNLIKELY (!priv->negotiated)) | |
| goto not_negotiated; | |
| /* Check for duplicate reference timestamp metadata */ | |
| ref_caps = gst_static_caps_get (&ntp_reference_timestamp_caps); | |
| meta = gst_buffer_get_reference_timestamp_meta (in, ref_caps); | |
| gst_caps_unref (ref_caps); | |
| if (meta) { | |
| guint64 ref_ts = meta->timestamp; | |
| if (ref_ts == priv->ref_ts) { | |
| /* Drop the redundant/duplicate reference timstamp metadata */ | |
| in = gst_buffer_make_writable (in); | |
| gst_buffer_remove_meta (in, GST_META_CAST (meta)); | |
| } else { | |
| priv->ref_ts = ref_ts; | |
| } | |
| } | |
| if (G_UNLIKELY (!gst_rtp_buffer_map (in, GST_MAP_READ, &rtp))) | |
| goto invalid_buffer; | |
| buf_discont = GST_BUFFER_IS_DISCONT (in); | |
| priv->pts = GST_BUFFER_PTS (in); | |
| priv->dts = GST_BUFFER_DTS (in); | |
| priv->duration = GST_BUFFER_DURATION (in); | |
| ssrc = gst_rtp_buffer_get_ssrc (&rtp); | |
| seqnum = gst_rtp_buffer_get_seq (&rtp); | |
| rtptime = gst_rtp_buffer_get_timestamp (&rtp); | |
| priv->last_seqnum = seqnum; | |
| priv->last_rtptime = rtptime; | |
| discont = buf_discont; | |
| GST_LOG_OBJECT (filter, "discont %d, seqnum %u, rtptime %u, pts %" | |
| GST_TIME_FORMAT ", dts %" GST_TIME_FORMAT, buf_discont, seqnum, rtptime, | |
| GST_TIME_ARGS (priv->pts), GST_TIME_ARGS (priv->dts)); | |
| /* Check seqnum. This is a very simple check that makes sure that the seqnums | |
| * are strictly increasing, dropping anything that is out of the ordinary. We | |
| * can only do this when the next_seqnum is known. */ | |
| if (G_LIKELY (priv->next_seqnum != -1)) { | |
| if (ssrc != priv->last_ssrc) { | |
| GST_LOG_OBJECT (filter, | |
| "New ssrc %u (current ssrc %u), sender restarted", | |
| ssrc, priv->last_ssrc); | |
| discont = TRUE; | |
| } else { | |
| gap = gst_rtp_buffer_compare_seqnum (seqnum, priv->next_seqnum); | |
| /* if we have no gap, all is fine */ | |
| if (G_UNLIKELY (gap != 0)) { | |
| GST_LOG_OBJECT (filter, "got packet %u, expected %u, gap %d", seqnum, | |
| priv->next_seqnum, gap); | |
| if (gap < 0) { | |
| /* seqnum > next_seqnum, we are missing some packets, this is always a | |
| * DISCONT. */ | |
| GST_LOG_OBJECT (filter, "%d missing packets", gap); | |
| discont = TRUE; | |
| } else { | |
| /* seqnum < next_seqnum, we have seen this packet before, have a | |
| * reordered packet or the sender could be restarted. If the packet | |
| * is not too old, we throw it away as a duplicate. Otherwise we | |
| * mark discont and continue assuming the sender has restarted. See | |
| * also RFC 4737. */ | |
| if (gap <= priv->max_reorder) { | |
| GST_WARNING_OBJECT (filter, "got old packet %u, expected %u, " | |
| "gap %d <= max_reorder (%d), dropping!", | |
| seqnum, priv->next_seqnum, gap, priv->max_reorder); | |
| goto dropping; | |
| } | |
| GST_WARNING_OBJECT (filter, "got old packet %u, expected %u, " | |
| "marking discont", seqnum, priv->next_seqnum); | |
| discont = TRUE; | |
| } | |
| } | |
| } | |
| } | |
| priv->next_seqnum = (seqnum + 1) & 0xffff; | |
| priv->last_ssrc = ssrc; | |
| if (G_UNLIKELY (discont)) { | |
| priv->discont = TRUE; | |
| if (!buf_discont) { | |
| gpointer old_inbuf = in; | |
| /* we detected a seqnum discont but the buffer was not flagged with a discont, | |
| * set the discont flag so that the subclass can throw away old data. */ | |
| GST_LOG_OBJECT (filter, "mark DISCONT on input buffer"); | |
| in = gst_buffer_make_writable (in); | |
| GST_BUFFER_FLAG_SET (in, GST_BUFFER_FLAG_DISCONT); | |
| /* depayloaders will check flag on rtpbuffer->buffer, so if the input | |
| * buffer was not writable already we need to remap to make our | |
| * newly-flagged buffer current on the rtpbuffer */ | |
| if (in != old_inbuf) { | |
| gst_rtp_buffer_unmap (&rtp); | |
| if (G_UNLIKELY (!gst_rtp_buffer_map (in, GST_MAP_READ, &rtp))) | |
| goto invalid_buffer; | |
| } | |
| } | |
| } | |
| /* prepare segment event if needed */ | |
| if (filter->need_newsegment) { | |
| priv->segment_event = create_segment_event (filter, rtptime, | |
| GST_BUFFER_PTS (in)); | |
| filter->need_newsegment = FALSE; | |
| } | |
| priv->input_buffer = in; | |
| if (discont) { | |
| gst_rtp_base_depayload_reset_hdrext_buffers (filter); | |
| g_assert_null (priv->hdrext_delayed); | |
| } | |
| /* update RTP buffer cache for header extensions if any */ | |
| if (priv->hdrext_aggregate && | |
| !priv->hdrext_seen && gst_rtp_buffer_get_extension (&rtp)) { | |
| GST_INFO_OBJECT (filter, "Activate RTP header ext aggregation"); | |
| priv->hdrext_seen = priv->hdrext_aggregate; | |
| } | |
| if (priv->hdrext_seen) { | |
| GstBuffer *b = gst_buffer_new (); | |
| /* make a copy of the buffer that only contains the RTP header | |
| with the extensions to not waste too much memory */ | |
| guint s = gst_rtp_buffer_get_header_len (&rtp); | |
| gst_buffer_copy_into (b, in, | |
| GST_BUFFER_COPY_MEMORY | GST_BUFFER_COPY_DEEP, 0, s); | |
| gst_buffer_list_add (priv->hdrext_buffers, b); | |
| } | |
| if (process_rtp_packet_func != NULL) { | |
| out_buf = process_rtp_packet_func (filter, &rtp); | |
| gst_rtp_buffer_unmap (&rtp); | |
| } else if (process_func != NULL) { | |
| gst_rtp_buffer_unmap (&rtp); | |
| out_buf = process_func (filter, in); | |
| } else { | |
| goto no_process; | |
| } | |
| /* let's send it out to processing */ | |
| if (out_buf) { | |
| if (priv->process_flow_ret == GST_FLOW_OK) { | |
| priv->process_flow_ret = gst_rtp_base_depayload_push (filter, out_buf); | |
| } else { | |
| gst_buffer_unref (out_buf); | |
| gst_rtp_base_depayload_reset_hdrext_buffers (filter); | |
| } | |
| } | |
| /* if the current buffer is delayed the depayloader should either | |
| have called gst_rtp_base_depayload_push() internally or returned | |
| a buffer that's pushed, either way the buffer cache should be | |
| empty here and we append the delayed buffer */ | |
| if (priv->hdrext_delayed) { | |
| g_assert_true (gst_buffer_list_length (priv->hdrext_buffers) == 0); | |
| gst_buffer_list_add (priv->hdrext_buffers, priv->hdrext_delayed); | |
| priv->hdrext_delayed = NULL; | |
| } | |
| gst_buffer_unref (in); | |
| priv->input_buffer = NULL; | |
| return priv->process_flow_ret; | |
| /* ERRORS */ | |
| not_negotiated: | |
| { | |
| /* this is not fatal but should be filtered earlier */ | |
| GST_ELEMENT_ERROR (filter, CORE, NEGOTIATION, | |
| ("No RTP format was negotiated."), | |
| ("Input buffers need to have RTP caps set on them. This is usually " | |
| "achieved by setting the 'caps' property of the upstream source " | |
| "element (often udpsrc or appsrc), or by putting a capsfilter " | |
| "element before the depayloader and setting the 'caps' property " | |
| "on that. Also see http://cgit.freedesktop.org/gstreamer/" | |
| "gst-plugins-good/tree/gst/rtp/README")); | |
| gst_buffer_unref (in); | |
| return GST_FLOW_NOT_NEGOTIATED; | |
| } | |
| invalid_buffer: | |
| { | |
| /* this is not fatal but should be filtered earlier */ | |
| GST_ELEMENT_WARNING (filter, STREAM, DECODE, (NULL), | |
| ("Received invalid RTP payload, dropping")); | |
| gst_buffer_unref (in); | |
| return GST_FLOW_OK; | |
| } | |
| dropping: | |
| { | |
| gst_rtp_buffer_unmap (&rtp); | |
| gst_buffer_unref (in); | |
| return GST_FLOW_OK; | |
| } | |
| no_process: | |
| { | |
| gst_rtp_buffer_unmap (&rtp); | |
| /* this is not fatal but should be filtered earlier */ | |
| GST_ELEMENT_ERROR (filter, STREAM, NOT_IMPLEMENTED, (NULL), | |
| ("The subclass does not have a process or process_rtp_packet method")); | |
| gst_buffer_unref (in); | |
| return GST_FLOW_ERROR; | |
| } | |
| } | |
| static GstFlowReturn | |
| gst_rtp_base_depayload_chain (GstPad * pad, GstObject * parent, GstBuffer * in) | |
| { | |
| GstRTPBaseDepayloadClass *bclass; | |
| GstRTPBaseDepayload *basedepay; | |
| GstFlowReturn flow_ret; | |
| basedepay = GST_RTP_BASE_DEPAYLOAD_CAST (parent); | |
| bclass = GST_RTP_BASE_DEPAYLOAD_GET_CLASS (basedepay); | |
| flow_ret = gst_rtp_base_depayload_handle_buffer (basedepay, bclass, in); | |
| return flow_ret; | |
| } | |
| static GstFlowReturn | |
| gst_rtp_base_depayload_chain_list (GstPad * pad, GstObject * parent, | |
| GstBufferList * list) | |
| { | |
| GstRTPBaseDepayloadClass *bclass; | |
| GstRTPBaseDepayload *basedepay; | |
| GstFlowReturn flow_ret; | |
| GstBuffer *buffer; | |
| guint i, len; | |
| basedepay = GST_RTP_BASE_DEPAYLOAD_CAST (parent); | |
| bclass = GST_RTP_BASE_DEPAYLOAD_GET_CLASS (basedepay); | |
| flow_ret = GST_FLOW_OK; | |
| /* chain each buffer in list individually */ | |
| len = gst_buffer_list_length (list); | |
| if (len == 0) | |
| goto done; | |
| for (i = 0; i < len; i++) { | |
| buffer = gst_buffer_list_get (list, i); | |
| /* handle_buffer takes ownership of input buffer */ | |
| /* FIXME: add a way to steal buffers from list as we will unref it anyway */ | |
| gst_buffer_ref (buffer); | |
| /* Should we fix up any missing timestamps for list buffers here | |
| * (e.g. set to first or previous timestamp in list) or just assume | |
| * the's a jitterbuffer that will have done that for us? */ | |
| flow_ret = gst_rtp_base_depayload_handle_buffer (basedepay, bclass, buffer); | |
| if (flow_ret != GST_FLOW_OK) | |
| break; | |
| } | |
| done: | |
| gst_buffer_list_unref (list); | |
| return flow_ret; | |
| } | |
| static gboolean | |
| gst_rtp_base_depayload_handle_event (GstRTPBaseDepayload * filter, | |
| GstEvent * event) | |
| { | |
| gboolean res = TRUE; | |
| gboolean forward = TRUE; | |
| switch (GST_EVENT_TYPE (event)) { | |
| case GST_EVENT_FLUSH_STOP: | |
| GST_OBJECT_LOCK (filter); | |
| gst_segment_init (&filter->segment, GST_FORMAT_UNDEFINED); | |
| GST_OBJECT_UNLOCK (filter); | |
| filter->need_newsegment = !filter->priv->onvif_mode; | |
| filter->priv->next_seqnum = -1; | |
| filter->priv->ref_ts = -1; | |
| gst_event_replace (&filter->priv->segment_event, NULL); | |
| break; | |
| case GST_EVENT_CAPS: | |
| { | |
| GstCaps *caps; | |
| gst_event_parse_caps (event, &caps); | |
| res = gst_rtp_base_depayload_setcaps (filter, caps); | |
| forward = FALSE; | |
| break; | |
| } | |
| case GST_EVENT_SEGMENT: | |
| { | |
| GstSegment segment; | |
| GST_OBJECT_LOCK (filter); | |
| gst_event_copy_segment (event, &segment); | |
| if (segment.format != GST_FORMAT_TIME) { | |
| GST_ERROR_OBJECT (filter, "Segment with non-TIME format not supported"); | |
| res = FALSE; | |
| } | |
| filter->priv->segment_seqnum = gst_event_get_seqnum (event); | |
| filter->segment = segment; | |
| GST_OBJECT_UNLOCK (filter); | |
| /* In ONVIF mode, upstream is expected to send us the correct segment */ | |
| if (!filter->priv->onvif_mode) { | |
| /* don't pass the event downstream, we generate our own segment including | |
| * the NTP time and other things we receive in caps */ | |
| forward = FALSE; | |
| } | |
| break; | |
| } | |
| case GST_EVENT_CUSTOM_DOWNSTREAM: | |
| { | |
| GstRTPBaseDepayloadClass *bclass; | |
| bclass = GST_RTP_BASE_DEPAYLOAD_GET_CLASS (filter); | |
| if (gst_event_has_name (event, "GstRTPPacketLost")) { | |
| /* we get this event from the jitterbuffer when it considers a packet as | |
| * being lost. We send it to our packet_lost vmethod. The default | |
| * implementation will make time progress by pushing out a GAP event. | |
| * Subclasses can override and do one of the following: | |
| * - Adjust timestamp/duration to something more accurate before | |
| * calling the parent (default) packet_lost method. | |
| * - do some more advanced error concealing on the already received | |
| * (fragmented) packets. | |
| * - ignore the packet lost. | |
| */ | |
| if (bclass->packet_lost) | |
| res = bclass->packet_lost (filter, event); | |
| forward = FALSE; | |
| } | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| if (forward) | |
| res = gst_pad_push_event (filter->srcpad, event); | |
| else | |
| gst_event_unref (event); | |
| return res; | |
| } | |
| static gboolean | |
| gst_rtp_base_depayload_handle_sink_event (GstPad * pad, GstObject * parent, | |
| GstEvent * event) | |
| { | |
| gboolean res = FALSE; | |
| GstRTPBaseDepayload *filter; | |
| GstRTPBaseDepayloadClass *bclass; | |
| filter = GST_RTP_BASE_DEPAYLOAD (parent); | |
| bclass = GST_RTP_BASE_DEPAYLOAD_GET_CLASS (filter); | |
| if (bclass->handle_event) | |
| res = bclass->handle_event (filter, event); | |
| else | |
| gst_event_unref (event); | |
| return res; | |
| } | |
| static GstEvent * | |
| create_segment_event (GstRTPBaseDepayload * filter, guint rtptime, | |
| GstClockTime position) | |
| { | |
| GstEvent *event; | |
| GstClockTime start, stop, running_time; | |
| GstRTPBaseDepayloadPrivate *priv; | |
| GstSegment segment; | |
| priv = filter->priv; | |
| /* We don't need the object lock around - the segment | |
| * can't change here while we're holding the STREAM_LOCK | |
| */ | |
| /* determining the start of the segment */ | |
| start = filter->segment.start; | |
| if (priv->clock_base != -1 && position != -1) { | |
| GstClockTime exttime, gap; | |
| exttime = priv->clock_base; | |
| gst_rtp_buffer_ext_timestamp (&exttime, rtptime); | |
| gap = gst_util_uint64_scale_int (exttime - priv->clock_base, | |
| filter->clock_rate, GST_SECOND); | |
| /* account for lost packets */ | |
| if (position > gap) { | |
| GST_DEBUG_OBJECT (filter, | |
| "Found gap of %" GST_TIME_FORMAT ", adjusting start: %" | |
| GST_TIME_FORMAT " = %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (gap), GST_TIME_ARGS (position - gap), | |
| GST_TIME_ARGS (position), GST_TIME_ARGS (gap)); | |
| start = position - gap; | |
| } | |
| } | |
| /* determining the stop of the segment */ | |
| stop = filter->segment.stop; | |
| if (priv->npt_stop != -1) | |
| stop = start + (priv->npt_stop - priv->npt_start); | |
| if (position == -1) | |
| position = start; | |
| running_time = gst_segment_to_running_time (&filter->segment, | |
| GST_FORMAT_TIME, start); | |
| gst_segment_init (&segment, GST_FORMAT_TIME); | |
| segment.rate = priv->play_speed; | |
| segment.applied_rate = priv->play_scale; | |
| segment.start = start; | |
| segment.stop = stop; | |
| segment.time = priv->npt_start; | |
| segment.position = position; | |
| segment.base = running_time; | |
| GST_DEBUG_OBJECT (filter, "Creating segment event %" GST_SEGMENT_FORMAT, | |
| &segment); | |
| event = gst_event_new_segment (&segment); | |
| if (filter->priv->segment_seqnum != GST_SEQNUM_INVALID) | |
| gst_event_set_seqnum (event, filter->priv->segment_seqnum); | |
| return event; | |
| } | |
| static gboolean | |
| foreach_metadata_drop (GstBuffer * buffer, GstMeta ** meta, gpointer user_data) | |
| { | |
| GType drop_api_type = (GType) user_data; | |
| const GstMetaInfo *info = (*meta)->info; | |
| if (info->api == drop_api_type) | |
| *meta = NULL; | |
| return TRUE; | |
| } | |
| static void | |
| add_rtp_source_meta (GstBuffer * outbuf, GstBuffer * rtpbuf) | |
| { | |
| GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; | |
| GstRTPSourceMeta *meta; | |
| guint32 ssrc; | |
| GType source_meta_api = gst_rtp_source_meta_api_get_type (); | |
| if (!gst_rtp_buffer_map (rtpbuf, GST_MAP_READ, &rtp)) | |
| return; | |
| ssrc = gst_rtp_buffer_get_ssrc (&rtp); | |
| /* remove any pre-existing source-meta */ | |
| gst_buffer_foreach_meta (outbuf, foreach_metadata_drop, | |
| (gpointer) source_meta_api); | |
| meta = gst_buffer_add_rtp_source_meta (outbuf, &ssrc, NULL, 0); | |
| if (meta != NULL) { | |
| gint i; | |
| gint csrc_count = gst_rtp_buffer_get_csrc_count (&rtp); | |
| for (i = 0; i < csrc_count; i++) { | |
| guint32 csrc = gst_rtp_buffer_get_csrc (&rtp, i); | |
| gst_rtp_source_meta_append_csrc (meta, &csrc, 1); | |
| } | |
| } | |
| gst_rtp_buffer_unmap (&rtp); | |
| } | |
| static void | |
| gst_rtp_base_depayload_add_extension (GstRTPBaseDepayload * rtpbasepayload, | |
| GstRTPHeaderExtension * ext) | |
| { | |
| g_return_if_fail (GST_IS_RTP_HEADER_EXTENSION (ext)); | |
| g_return_if_fail (gst_rtp_header_extension_get_id (ext) > 0); | |
| /* XXX: check for duplicate ids? */ | |
| GST_OBJECT_LOCK (rtpbasepayload); | |
| g_ptr_array_add (rtpbasepayload->priv->header_exts, gst_object_ref (ext)); | |
| GST_OBJECT_UNLOCK (rtpbasepayload); | |
| g_object_notify_by_pspec (G_OBJECT (rtpbasepayload), | |
| gst_rtp_base_depayload_extensions_pspec); | |
| } | |
| static void | |
| gst_rtp_base_depayload_clear_extensions (GstRTPBaseDepayload * rtpbasepayload) | |
| { | |
| GST_OBJECT_LOCK (rtpbasepayload); | |
| g_ptr_array_set_size (rtpbasepayload->priv->header_exts, 0); | |
| GST_OBJECT_UNLOCK (rtpbasepayload); | |
| g_object_notify_by_pspec (G_OBJECT (rtpbasepayload), | |
| gst_rtp_base_depayload_extensions_pspec); | |
| } | |
| static void | |
| gst_rtp_base_depayload_get_extensions (GstRTPBaseDepayload * depayload, | |
| GValue * out_value) | |
| { | |
| GPtrArray *extensions; | |
| guint i; | |
| GST_OBJECT_LOCK (depayload); | |
| extensions = depayload->priv->header_exts; | |
| for (i = 0; i < extensions->len; ++i) { | |
| GValue value = G_VALUE_INIT; | |
| g_value_init (&value, GST_TYPE_RTP_HEADER_EXTENSION); | |
| g_value_set_object (&value, g_ptr_array_index (extensions, i)); | |
| gst_value_array_append_and_take_value (out_value, &value); | |
| } | |
| GST_OBJECT_UNLOCK (depayload); | |
| } | |
| static gboolean | |
| read_rtp_header_extensions (GstRTPBaseDepayload * depayload, | |
| GstBuffer * input, GstBuffer * output) | |
| { | |
| GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; | |
| guint16 bit_pattern; | |
| guint8 *pdata; | |
| guint wordlen; | |
| gboolean needs_src_caps_update = FALSE; | |
| if (!input) { | |
| GST_DEBUG_OBJECT (depayload, "no input buffer"); | |
| return needs_src_caps_update; | |
| } | |
| if (!gst_rtp_buffer_map (input, GST_MAP_READ, &rtp)) { | |
| GST_WARNING_OBJECT (depayload, "Failed to map buffer"); | |
| return needs_src_caps_update; | |
| } | |
| if (gst_rtp_buffer_get_extension_data (&rtp, &bit_pattern, (gpointer) & pdata, | |
| &wordlen)) { | |
| GstRTPHeaderExtensionFlags ext_flags = 0; | |
| gsize bytelen = wordlen * 4; | |
| guint hdr_unit_bytes; | |
| gsize offset = 0; | |
| if (bit_pattern == 0xBEDE) { | |
| /* one byte extensions */ | |
| hdr_unit_bytes = 1; | |
| ext_flags |= GST_RTP_HEADER_EXTENSION_ONE_BYTE; | |
| } else if (bit_pattern >> 4 == 0x100) { | |
| /* two byte extensions */ | |
| hdr_unit_bytes = 2; | |
| ext_flags |= GST_RTP_HEADER_EXTENSION_TWO_BYTE; | |
| } else { | |
| GST_DEBUG_OBJECT (depayload, "unknown extension bit pattern 0x%02x%02x", | |
| bit_pattern >> 8, bit_pattern & 0xff); | |
| goto out; | |
| } | |
| while (TRUE) { | |
| guint8 read_id, read_len; | |
| GstRTPHeaderExtension *ext = NULL; | |
| guint i; | |
| if (offset + hdr_unit_bytes >= bytelen) | |
| /* not enough remaning data */ | |
| break; | |
| if (ext_flags & GST_RTP_HEADER_EXTENSION_ONE_BYTE) { | |
| read_id = GST_READ_UINT8 (pdata + offset) >> 4; | |
| read_len = (GST_READ_UINT8 (pdata + offset) & 0x0F) + 1; | |
| offset += 1; | |
| if (read_id == 0) | |
| /* padding */ | |
| continue; | |
| if (read_id == 15) | |
| /* special id for possible future expansion */ | |
| break; | |
| } else { | |
| read_id = GST_READ_UINT8 (pdata + offset); | |
| offset += 1; | |
| if (read_id == 0) | |
| /* padding */ | |
| continue; | |
| read_len = GST_READ_UINT8 (pdata + offset); | |
| offset += 1; | |
| } | |
| GST_TRACE_OBJECT (depayload, "found rtp header extension with id %u and " | |
| "length %u", read_id, read_len); | |
| /* Ignore extension headers where the size does not fit */ | |
| if (offset + read_len > bytelen) { | |
| GST_WARNING_OBJECT (depayload, "Extension length extends past the " | |
| "size of the extension data"); | |
| break; | |
| } | |
| GST_OBJECT_LOCK (depayload); | |
| for (i = 0; i < depayload->priv->header_exts->len; i++) { | |
| ext = g_ptr_array_index (depayload->priv->header_exts, i); | |
| if (read_id == gst_rtp_header_extension_get_id (ext)) { | |
| gst_object_ref (ext); | |
| break; | |
| } | |
| ext = NULL; | |
| } | |
| if (ext) { | |
| if (!gst_rtp_header_extension_read (ext, ext_flags, &pdata[offset], | |
| read_len, output)) { | |
| GST_WARNING_OBJECT (depayload, "RTP header extension (%s) could " | |
| "not read payloaded data", GST_OBJECT_NAME (ext)); | |
| gst_object_unref (ext); | |
| goto out; | |
| } | |
| if (gst_rtp_header_extension_wants_update_non_rtp_src_caps (ext)) { | |
| needs_src_caps_update = TRUE; | |
| } | |
| gst_object_unref (ext); | |
| } | |
| GST_OBJECT_UNLOCK (depayload); | |
| offset += read_len; | |
| } | |
| } | |
| out: | |
| gst_rtp_buffer_unmap (&rtp); | |
| return needs_src_caps_update; | |
| } | |
| static gboolean | |
| gst_rtp_base_depayload_operate_hdrext_buffer (GstBuffer ** buffer, | |
| guint idx, gpointer depayloader) | |
| { | |
| GstRTPBaseDepayload *depayload = depayloader; | |
| depayload->priv->hdrext_read_result |= | |
| read_rtp_header_extensions (depayload, *buffer, | |
| depayload->priv->hdrext_outbuf); | |
| return TRUE; | |
| } | |
| static void | |
| gst_rtp_base_depayload_reset_hdrext_buffers (GstRTPBaseDepayload * depayload) | |
| { | |
| GstRTPBaseDepayloadPrivate *priv = depayload->priv; | |
| gst_buffer_list_unref (priv->hdrext_buffers); | |
| priv->hdrext_buffers = gst_buffer_list_new (); | |
| } | |
| static gboolean | |
| gst_rtp_base_depayload_set_headers (GstRTPBaseDepayload * depayload, | |
| GstBuffer * buffer) | |
| { | |
| GstRTPBaseDepayloadPrivate *priv = depayload->priv; | |
| GstClockTime pts, dts, duration; | |
| gboolean ret = FALSE; | |
| pts = GST_BUFFER_PTS (buffer); | |
| dts = GST_BUFFER_DTS (buffer); | |
| duration = GST_BUFFER_DURATION (buffer); | |
| /* apply last incoming timestamp and duration to outgoing buffer if | |
| * not otherwise set. */ | |
| if (!GST_CLOCK_TIME_IS_VALID (pts)) | |
| GST_BUFFER_PTS (buffer) = priv->pts; | |
| if (!GST_CLOCK_TIME_IS_VALID (dts)) | |
| GST_BUFFER_DTS (buffer) = priv->dts; | |
| if (!GST_CLOCK_TIME_IS_VALID (duration)) | |
| GST_BUFFER_DURATION (buffer) = priv->duration; | |
| if (G_UNLIKELY (depayload->priv->discont)) { | |
| GST_LOG_OBJECT (depayload, "Marking DISCONT on output buffer"); | |
| GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT); | |
| depayload->priv->discont = FALSE; | |
| } | |
| /* make sure we only set the timestamp on the first packet */ | |
| priv->pts = GST_CLOCK_TIME_NONE; | |
| priv->dts = GST_CLOCK_TIME_NONE; | |
| priv->duration = GST_CLOCK_TIME_NONE; | |
| if (priv->input_buffer) { | |
| if (priv->source_info) | |
| add_rtp_source_meta (buffer, priv->input_buffer); | |
| if (priv->hdrext_aggregate) { | |
| priv->hdrext_read_result = FALSE; | |
| priv->hdrext_outbuf = buffer; | |
| /* if we have an empty list but a delayed RTP buffer let's use it */ | |
| if (!gst_buffer_list_length (priv->hdrext_buffers) && | |
| priv->hdrext_delayed) { | |
| gst_buffer_list_add (priv->hdrext_buffers, priv->hdrext_delayed); | |
| priv->hdrext_delayed = NULL; | |
| } | |
| gst_buffer_list_foreach (priv->hdrext_buffers, | |
| gst_rtp_base_depayload_operate_hdrext_buffer, depayload); | |
| ret = priv->hdrext_read_result; | |
| priv->hdrext_outbuf = NULL; | |
| } else { | |
| ret = read_rtp_header_extensions (depayload, priv->input_buffer, buffer); | |
| } | |
| } | |
| return ret; | |
| } | |
| static GstFlowReturn | |
| gst_rtp_base_depayload_finish_push (GstRTPBaseDepayload * filter, | |
| gboolean is_list, gpointer obj) | |
| { | |
| /* if this is the first buffer send a NEWSEGMENT */ | |
| if (G_UNLIKELY (filter->priv->segment_event)) { | |
| gst_pad_push_event (filter->srcpad, filter->priv->segment_event); | |
| filter->priv->segment_event = NULL; | |
| GST_DEBUG_OBJECT (filter, "Pushed newsegment event on this first buffer"); | |
| } | |
| if (is_list) { | |
| GstBufferList *blist = obj; | |
| return gst_pad_push_list (filter->srcpad, blist); | |
| } else { | |
| GstBuffer *buf = obj; | |
| return gst_pad_push (filter->srcpad, buf); | |
| } | |
| } | |
| static gboolean | |
| gst_rtp_base_depayload_set_src_caps_from_hdrext (GstRTPBaseDepayload * filter) | |
| { | |
| gboolean update_ok = TRUE; | |
| GstCaps *src_caps = gst_pad_get_current_caps (filter->srcpad); | |
| if (src_caps) { | |
| GstCaps *new_caps; | |
| gint i; | |
| new_caps = gst_caps_copy (src_caps); | |
| for (i = 0; i < filter->priv->header_exts->len; i++) { | |
| GstRTPHeaderExtension *ext; | |
| ext = g_ptr_array_index (filter->priv->header_exts, i); | |
| update_ok = | |
| gst_rtp_header_extension_update_non_rtp_src_caps (ext, new_caps); | |
| if (!update_ok) { | |
| GST_ELEMENT_ERROR (filter, STREAM, DECODE, | |
| ("RTP header extension (%s) could not update src caps", | |
| GST_OBJECT_NAME (ext)), (NULL)); | |
| break; | |
| } | |
| } | |
| if (G_UNLIKELY (update_ok && !gst_caps_is_equal (src_caps, new_caps))) { | |
| gst_pad_set_caps (filter->srcpad, new_caps); | |
| } | |
| gst_caps_unref (src_caps); | |
| gst_caps_unref (new_caps); | |
| } | |
| return update_ok; | |
| } | |
| static GstFlowReturn | |
| gst_rtp_base_depayload_do_push (GstRTPBaseDepayload * filter, gboolean is_list, | |
| gpointer obj) | |
| { | |
| GstFlowReturn res; | |
| if (is_list) { | |
| GstBufferList *blist = obj; | |
| guint i; | |
| guint first_not_pushed_idx = 0; | |
| for (i = 0; i < gst_buffer_list_length (blist); ++i) { | |
| GstBuffer *buf = gst_buffer_list_get_writable (blist, i); | |
| if (G_UNLIKELY (gst_rtp_base_depayload_set_headers (filter, buf))) { | |
| /* src caps have changed; push the buffers preceding the current one, | |
| * then apply the new caps on the src pad */ | |
| guint j; | |
| for (j = first_not_pushed_idx; j < i; ++j) { | |
| res = gst_rtp_base_depayload_finish_push (filter, FALSE, | |
| gst_buffer_ref (gst_buffer_list_get (blist, j))); | |
| if (G_UNLIKELY (res != GST_FLOW_OK)) { | |
| goto error_list; | |
| } | |
| } | |
| first_not_pushed_idx = i; | |
| if (!gst_rtp_base_depayload_set_src_caps_from_hdrext (filter)) { | |
| res = GST_FLOW_ERROR; | |
| goto error_list; | |
| } | |
| } | |
| } | |
| if (G_LIKELY (first_not_pushed_idx == 0)) { | |
| res = gst_rtp_base_depayload_finish_push (filter, TRUE, blist); | |
| blist = NULL; | |
| } else { | |
| for (i = first_not_pushed_idx; i < gst_buffer_list_length (blist); ++i) { | |
| res = gst_rtp_base_depayload_finish_push (filter, FALSE, | |
| gst_buffer_ref (gst_buffer_list_get (blist, i))); | |
| if (G_UNLIKELY (res != GST_FLOW_OK)) { | |
| break; | |
| } | |
| } | |
| } | |
| error_list: | |
| gst_clear_buffer_list (&blist); | |
| } else { | |
| GstBuffer *buf = obj; | |
| if (G_UNLIKELY (gst_rtp_base_depayload_set_headers (filter, buf))) { | |
| if (!gst_rtp_base_depayload_set_src_caps_from_hdrext (filter)) { | |
| res = GST_FLOW_ERROR; | |
| goto error_buffer; | |
| } | |
| } | |
| res = gst_rtp_base_depayload_finish_push (filter, FALSE, buf); | |
| buf = NULL; | |
| error_buffer: | |
| gst_clear_buffer (&buf); | |
| } | |
| gst_rtp_base_depayload_reset_hdrext_buffers (filter); | |
| return res; | |
| } | |
| /** | |
| * gst_rtp_base_depayload_push: | |
| * @filter: a #GstRTPBaseDepayload | |
| * @out_buf: (transfer full): a #GstBuffer | |
| * | |
| * Push @out_buf to the peer of @filter. This function takes ownership of | |
| * @out_buf. | |
| * | |
| * This function will by default apply the last incoming timestamp on | |
| * the outgoing buffer when it didn't have a timestamp already. | |
| * | |
| * Returns: a #GstFlowReturn. | |
| */ | |
| GstFlowReturn | |
| gst_rtp_base_depayload_push (GstRTPBaseDepayload * filter, GstBuffer * out_buf) | |
| { | |
| GstFlowReturn res; | |
| res = gst_rtp_base_depayload_do_push (filter, FALSE, out_buf); | |
| if (res != GST_FLOW_OK) | |
| filter->priv->process_flow_ret = res; | |
| return res; | |
| } | |
| /** | |
| * gst_rtp_base_depayload_push_list: | |
| * @filter: a #GstRTPBaseDepayload | |
| * @out_list: (transfer full): a #GstBufferList | |
| * | |
| * Push @out_list to the peer of @filter. This function takes ownership of | |
| * @out_list. | |
| * | |
| * Returns: a #GstFlowReturn. | |
| */ | |
| GstFlowReturn | |
| gst_rtp_base_depayload_push_list (GstRTPBaseDepayload * filter, | |
| GstBufferList * out_list) | |
| { | |
| GstFlowReturn res; | |
| res = gst_rtp_base_depayload_do_push (filter, TRUE, out_list); | |
| if (res != GST_FLOW_OK) | |
| filter->priv->process_flow_ret = res; | |
| return res; | |
| } | |
| /* convert the PacketLost event from a jitterbuffer to a GAP event. | |
| * subclasses can override this. */ | |
| static gboolean | |
| gst_rtp_base_depayload_packet_lost (GstRTPBaseDepayload * filter, | |
| GstEvent * event) | |
| { | |
| GstClockTime timestamp, duration; | |
| GstEvent *sevent; | |
| const GstStructure *s; | |
| gboolean might_have_been_fec; | |
| gboolean res = TRUE; | |
| s = gst_event_get_structure (event); | |
| /* first start by parsing the timestamp and duration */ | |
| timestamp = -1; | |
| duration = -1; | |
| if (!gst_structure_get_clock_time (s, "timestamp", ×tamp) || | |
| !gst_structure_get_clock_time (s, "duration", &duration)) { | |
| GST_ERROR_OBJECT (filter, | |
| "Packet loss event without timestamp or duration"); | |
| return FALSE; | |
| } | |
| sevent = gst_pad_get_sticky_event (filter->srcpad, GST_EVENT_SEGMENT, 0); | |
| if (G_UNLIKELY (!sevent)) { | |
| /* Typically happens if lost event arrives before first buffer */ | |
| GST_DEBUG_OBJECT (filter, | |
| "Ignore packet loss because segment event missing"); | |
| return FALSE; | |
| } | |
| gst_event_unref (sevent); | |
| if (!gst_structure_get_boolean (s, "might-have-been-fec", | |
| &might_have_been_fec) || !might_have_been_fec) { | |
| /* send GAP event */ | |
| sevent = gst_event_new_gap (timestamp, duration); | |
| gst_event_set_gap_flags (sevent, GST_GAP_FLAG_MISSING_DATA); | |
| res = gst_pad_push_event (filter->srcpad, sevent); | |
| } | |
| return res; | |
| } | |
| static GstStateChangeReturn | |
| gst_rtp_base_depayload_change_state (GstElement * element, | |
| GstStateChange transition) | |
| { | |
| GstRTPBaseDepayload *filter; | |
| GstRTPBaseDepayloadPrivate *priv; | |
| GstStateChangeReturn ret; | |
| filter = GST_RTP_BASE_DEPAYLOAD (element); | |
| priv = filter->priv; | |
| switch (transition) { | |
| case GST_STATE_CHANGE_NULL_TO_READY: | |
| break; | |
| case GST_STATE_CHANGE_READY_TO_PAUSED: | |
| filter->need_newsegment = TRUE; | |
| priv->npt_start = 0; | |
| priv->npt_stop = -1; | |
| priv->play_speed = 1.0; | |
| priv->play_scale = 1.0; | |
| priv->clock_base = -1; | |
| priv->ref_ts = -1; | |
| priv->onvif_mode = FALSE; | |
| priv->next_seqnum = -1; | |
| priv->negotiated = FALSE; | |
| priv->discont = FALSE; | |
| priv->segment_seqnum = GST_SEQNUM_INVALID; | |
| priv->hdrext_seen = FALSE; | |
| if (priv->hdrext_delayed) | |
| gst_buffer_unref (priv->hdrext_delayed); | |
| gst_rtp_base_depayload_reset_hdrext_buffers (filter); | |
| break; | |
| case GST_STATE_CHANGE_PAUSED_TO_PLAYING: | |
| break; | |
| default: | |
| break; | |
| } | |
| ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); | |
| switch (transition) { | |
| case GST_STATE_CHANGE_PLAYING_TO_PAUSED: | |
| break; | |
| case GST_STATE_CHANGE_PAUSED_TO_READY: | |
| gst_caps_replace (&priv->last_caps, NULL); | |
| gst_event_replace (&priv->segment_event, NULL); | |
| break; | |
| case GST_STATE_CHANGE_READY_TO_NULL: | |
| break; | |
| default: | |
| break; | |
| } | |
| return ret; | |
| } | |
| static GstStructure * | |
| gst_rtp_base_depayload_create_stats (GstRTPBaseDepayload * depayload) | |
| { | |
| GstRTPBaseDepayloadPrivate *priv; | |
| GstStructure *s; | |
| GstClockTime pts = GST_CLOCK_TIME_NONE, dts = GST_CLOCK_TIME_NONE; | |
| priv = depayload->priv; | |
| GST_OBJECT_LOCK (depayload); | |
| if (depayload->segment.format != GST_FORMAT_UNDEFINED) { | |
| pts = gst_segment_to_running_time (&depayload->segment, GST_FORMAT_TIME, | |
| priv->pts); | |
| dts = gst_segment_to_running_time (&depayload->segment, GST_FORMAT_TIME, | |
| priv->dts); | |
| } | |
| GST_OBJECT_UNLOCK (depayload); | |
| s = gst_structure_new ("application/x-rtp-depayload-stats", | |
| "clock_rate", G_TYPE_UINT, depayload->clock_rate, | |
| "npt-start", G_TYPE_UINT64, priv->npt_start, | |
| "npt-stop", G_TYPE_UINT64, priv->npt_stop, | |
| "play-speed", G_TYPE_DOUBLE, priv->play_speed, | |
| "play-scale", G_TYPE_DOUBLE, priv->play_scale, | |
| "running-time-dts", G_TYPE_UINT64, dts, | |
| "running-time-pts", G_TYPE_UINT64, pts, | |
| "seqnum", G_TYPE_UINT, (guint) priv->last_seqnum, | |
| "timestamp", G_TYPE_UINT, (guint) priv->last_rtptime, NULL); | |
| return s; | |
| } | |
| static void | |
| gst_rtp_base_depayload_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec) | |
| { | |
| GstRTPBaseDepayload *depayload; | |
| GstRTPBaseDepayloadPrivate *priv; | |
| depayload = GST_RTP_BASE_DEPAYLOAD (object); | |
| priv = depayload->priv; | |
| switch (prop_id) { | |
| case PROP_SOURCE_INFO: | |
| gst_rtp_base_depayload_set_source_info_enabled (depayload, | |
| g_value_get_boolean (value)); | |
| break; | |
| case PROP_MAX_REORDER: | |
| priv->max_reorder = g_value_get_int (value); | |
| break; | |
| case PROP_AUTO_HEADER_EXTENSION: | |
| priv->auto_hdr_ext = g_value_get_boolean (value); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| static void | |
| gst_rtp_base_depayload_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec) | |
| { | |
| GstRTPBaseDepayload *depayload; | |
| GstRTPBaseDepayloadPrivate *priv; | |
| depayload = GST_RTP_BASE_DEPAYLOAD (object); | |
| priv = depayload->priv; | |
| switch (prop_id) { | |
| case PROP_STATS: | |
| g_value_take_boxed (value, | |
| gst_rtp_base_depayload_create_stats (depayload)); | |
| break; | |
| case PROP_SOURCE_INFO: | |
| g_value_set_boolean (value, | |
| gst_rtp_base_depayload_is_source_info_enabled (depayload)); | |
| break; | |
| case PROP_MAX_REORDER: | |
| g_value_set_int (value, priv->max_reorder); | |
| break; | |
| case PROP_AUTO_HEADER_EXTENSION: | |
| g_value_set_boolean (value, priv->auto_hdr_ext); | |
| break; | |
| case PROP_EXTENSIONS: | |
| gst_rtp_base_depayload_get_extensions (depayload, value); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| /** | |
| * gst_rtp_base_depayload_set_source_info_enabled: | |
| * @depayload: a #GstRTPBaseDepayload | |
| * @enable: whether to add meta about RTP sources to buffer | |
| * | |
| * Enable or disable adding #GstRTPSourceMeta to depayloaded buffers. | |
| * | |
| * Since: 1.16 | |
| **/ | |
| void | |
| gst_rtp_base_depayload_set_source_info_enabled (GstRTPBaseDepayload * depayload, | |
| gboolean enable) | |
| { | |
| depayload->priv->source_info = enable; | |
| } | |
| /** | |
| * gst_rtp_base_depayload_is_source_info_enabled: | |
| * @depayload: a #GstRTPBaseDepayload | |
| * | |
| * Queries whether #GstRTPSourceMeta will be added to depayloaded buffers. | |
| * | |
| * Returns: %TRUE if source-info is enabled. | |
| * | |
| * Since: 1.16 | |
| **/ | |
| gboolean | |
| gst_rtp_base_depayload_is_source_info_enabled (GstRTPBaseDepayload * depayload) | |
| { | |
| return depayload->priv->source_info; | |
| } | |
| /** | |
| * gst_rtp_base_depayload_set_aggregate_hdrext_enabled: | |
| * @depayload: a #GstRTPBaseDepayload | |
| * @enable: whether to aggregate header extensions per output buffer | |
| * | |
| * Enable or disable aggregating header extensions. | |
| * | |
| * Since: 1.24 | |
| **/ | |
| void | |
| gst_rtp_base_depayload_set_aggregate_hdrext_enabled (GstRTPBaseDepayload * | |
| depayload, gboolean enable) | |
| { | |
| depayload->priv->hdrext_aggregate = enable; | |
| if (!enable) | |
| gst_rtp_base_depayload_reset_hdrext_buffers (depayload); | |
| } | |
| /** | |
| * gst_rtp_base_depayload_is_aggregate_hdrext_enabled: | |
| * @depayload: a #GstRTPBaseDepayload | |
| * | |
| * Queries whether header extensions will be aggregated per depayloaded buffers. | |
| * | |
| * Returns: %TRUE if aggregate-header-extension is enabled. | |
| * | |
| * Since: 1.24 | |
| **/ | |
| gboolean | |
| gst_rtp_base_depayload_is_aggregate_hdrext_enabled (GstRTPBaseDepayload * | |
| depayload) | |
| { | |
| return depayload->priv->hdrext_aggregate; | |
| } | |
| /** | |
| * gst_rtp_base_depayload_dropped: | |
| * @depayload: a #GstRTPBaseDepayload | |
| * | |
| * Called from @GstRTPBaseDepayload.process or | |
| * @GstRTPBaseDepayload.process_rtp_packet if the depayloader does not | |
| * use the current buffer for the output buffer. This will either drop | |
| * the delayed buffer or the last buffer from the header extension | |
| * cache. | |
| * | |
| * A typical use-case is when the depayloader implementation is | |
| * dropping an input RTP buffer while waiting for the first keyframe. | |
| * | |
| * Must be called with the stream lock held. | |
| * | |
| * Since: 1.24 | |
| **/ | |
| void | |
| gst_rtp_base_depayload_dropped (GstRTPBaseDepayload * depayload) | |
| { | |
| GstRTPBaseDepayloadPrivate *priv = depayload->priv; | |
| guint l = gst_buffer_list_length (priv->hdrext_buffers); | |
| if (priv->hdrext_delayed) { | |
| gst_clear_buffer (&priv->hdrext_delayed); | |
| } else if (l) { | |
| gst_buffer_list_remove (priv->hdrext_buffers, l - 1, 1); | |
| } | |
| } | |
| /** | |
| * gst_rtp_base_depayload_delayed: | |
| * @depayload: a #GstRTPBaseDepayload | |
| * | |
| * Called from @GstRTPBaseDepayload.process or | |
| * @GstRTPBaseDepayload.process_rtp_packet when the depayloader needs | |
| * to keep the current input RTP header for use with the next output | |
| * buffer. | |
| * | |
| * The delayed buffer will remain until the end of processing the | |
| * current output buffer and then enqueued for processing with the | |
| * next output buffer. | |
| * | |
| * A typical use-case is when the depayloader implementation will | |
| * start a new output buffer for the current input RTP buffer but push | |
| * the current output buffer first. | |
| * | |
| * Must be called with the stream lock held. | |
| * | |
| * Since: 1.24 | |
| **/ | |
| void | |
| gst_rtp_base_depayload_delayed (GstRTPBaseDepayload * depayload) | |
| { | |
| GstRTPBaseDepayloadPrivate *priv = depayload->priv; | |
| guint l = gst_buffer_list_length (priv->hdrext_buffers); | |
| if (l) { | |
| priv->hdrext_delayed = gst_buffer_list_get (priv->hdrext_buffers, l - 1); | |
| gst_buffer_ref (priv->hdrext_delayed); | |
| gst_buffer_list_remove (priv->hdrext_buffers, l - 1, 1); | |
| } | |
| } | |
| /** | |
| * gst_rtp_base_depayload_flush: | |
| * @depayload: a #GstRTPBaseDepayload | |
| * @keep_current: if the current RTP buffer shall be kept | |
| * | |
| * If @GstRTPBaseDepayload.process or | |
| * @GstRTPBaseDepayload.process_rtp_packet drop an output buffer this | |
| * function tells the base class to flush header extension cache as | |
| * well. | |
| * | |
| * This will not drop an input RTP header marked as delayed from | |
| * gst_rtp_base_depayload_delayed(). | |
| * | |
| * If @keep_current is %TRUE the current input RTP header will be kept | |
| * and enqueued after flushing the previous input RTP headers. | |
| * | |
| * A typical use-case for @keep_current is when the depayloader | |
| * implementation invalidates the current output buffer and starts a | |
| * new one with the current RTP input buffer. | |
| * | |
| * Must be called with the stream lock held. | |
| * | |
| * Since: 1.24 | |
| **/ | |
| void | |
| gst_rtp_base_depayload_flush (GstRTPBaseDepayload * depayload, | |
| gboolean keep_current) | |
| { | |
| GstRTPBaseDepayloadPrivate *priv = depayload->priv; | |
| guint l = gst_buffer_list_length (priv->hdrext_buffers); | |
| /* if the current buffer shall not be kept or has already been | |
| removed from the cache clear the cache */ | |
| if (!keep_current || priv->hdrext_delayed) { | |
| gst_rtp_base_depayload_reset_hdrext_buffers (depayload); | |
| } else if (l) { | |
| /* clear all cached buffers (if any) except the delayed */ | |
| GstBuffer *b = gst_buffer_list_get (priv->hdrext_buffers, l - 1); | |
| gst_buffer_ref (b); | |
| gst_rtp_base_depayload_reset_hdrext_buffers (depayload); | |
| gst_buffer_list_add (priv->hdrext_buffers, b); | |
| } | |
| } |