| /* GStreamer | |
| * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.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. | |
| */ | |
| /* FIXME 0.11: suppress warnings for deprecated API such as GValueArray | |
| * with newer GLib versions (>= 2.31.0) */ | |
| #define GLIB_DISABLE_DEPRECATION_WARNINGS | |
| #include <string.h> | |
| #include <stdlib.h> | |
| #include <gst/rtp/gstrtpbuffer.h> | |
| #include <gst/rtp/gstrtcpbuffer.h> | |
| #include <gst/glib-compat-private.h> | |
| #include "rtpsession.h" | |
| #include "gstrtputils.h" | |
| GST_DEBUG_CATEGORY (rtp_session_debug); | |
| #define GST_CAT_DEFAULT rtp_session_debug | |
| /* signals and args */ | |
| enum | |
| { | |
| SIGNAL_GET_SOURCE_BY_SSRC, | |
| SIGNAL_ON_NEW_SSRC, | |
| SIGNAL_ON_SSRC_COLLISION, | |
| SIGNAL_ON_SSRC_VALIDATED, | |
| SIGNAL_ON_SSRC_ACTIVE, | |
| SIGNAL_ON_SSRC_SDES, | |
| SIGNAL_ON_BYE_SSRC, | |
| SIGNAL_ON_BYE_TIMEOUT, | |
| SIGNAL_ON_TIMEOUT, | |
| SIGNAL_ON_SENDER_TIMEOUT, | |
| SIGNAL_ON_SENDING_RTCP, | |
| SIGNAL_ON_APP_RTCP, | |
| SIGNAL_ON_FEEDBACK_RTCP, | |
| SIGNAL_SEND_RTCP, | |
| SIGNAL_SEND_RTCP_FULL, | |
| SIGNAL_ON_RECEIVING_RTCP, | |
| SIGNAL_ON_NEW_SENDER_SSRC, | |
| SIGNAL_ON_SENDER_SSRC_ACTIVE, | |
| SIGNAL_ON_SENDING_NACKS, | |
| LAST_SIGNAL | |
| }; | |
| #define DEFAULT_INTERNAL_SOURCE NULL | |
| #define DEFAULT_BANDWIDTH 0.0 | |
| #define DEFAULT_RTCP_FRACTION RTP_STATS_RTCP_FRACTION | |
| #define DEFAULT_RTCP_RR_BANDWIDTH -1 | |
| #define DEFAULT_RTCP_RS_BANDWIDTH -1 | |
| #define DEFAULT_RTCP_MTU 1400 | |
| #define DEFAULT_SDES NULL | |
| #define DEFAULT_NUM_SOURCES 0 | |
| #define DEFAULT_NUM_ACTIVE_SOURCES 0 | |
| #define DEFAULT_SOURCES NULL | |
| #define DEFAULT_RTCP_MIN_INTERVAL (RTP_STATS_MIN_INTERVAL * GST_SECOND) | |
| #define DEFAULT_RTCP_FEEDBACK_RETENTION_WINDOW (2 * GST_SECOND) | |
| #define DEFAULT_RTCP_IMMEDIATE_FEEDBACK_THRESHOLD (3) | |
| #define DEFAULT_PROBATION RTP_DEFAULT_PROBATION | |
| #define DEFAULT_MAX_DROPOUT_TIME 60000 | |
| #define DEFAULT_MAX_MISORDER_TIME 2000 | |
| #define DEFAULT_RTP_PROFILE GST_RTP_PROFILE_AVP | |
| #define DEFAULT_RTCP_REDUCED_SIZE FALSE | |
| #define DEFAULT_RTCP_DISABLE_SR_TIMESTAMP FALSE | |
| #define DEFAULT_FAVOR_NEW FALSE | |
| #define DEFAULT_TWCC_FEEDBACK_INTERVAL GST_CLOCK_TIME_NONE | |
| #define DEFAULT_UPDATE_NTP64_HEADER_EXT TRUE | |
| #define DEFAULT_TIMEOUT_INACTIVE_SOURCES TRUE | |
| enum | |
| { | |
| PROP_0, | |
| PROP_INTERNAL_SSRC, | |
| PROP_INTERNAL_SOURCE, | |
| PROP_BANDWIDTH, | |
| PROP_RTCP_FRACTION, | |
| PROP_RTCP_RR_BANDWIDTH, | |
| PROP_RTCP_RS_BANDWIDTH, | |
| PROP_RTCP_MTU, | |
| PROP_SDES, | |
| PROP_NUM_SOURCES, | |
| PROP_NUM_ACTIVE_SOURCES, | |
| PROP_SOURCES, | |
| PROP_FAVOR_NEW, | |
| PROP_RTCP_MIN_INTERVAL, | |
| PROP_RTCP_FEEDBACK_RETENTION_WINDOW, | |
| PROP_RTCP_IMMEDIATE_FEEDBACK_THRESHOLD, | |
| PROP_PROBATION, | |
| PROP_MAX_DROPOUT_TIME, | |
| PROP_MAX_MISORDER_TIME, | |
| PROP_STATS, | |
| PROP_RTP_PROFILE, | |
| PROP_RTCP_REDUCED_SIZE, | |
| PROP_RTCP_DISABLE_SR_TIMESTAMP, | |
| PROP_TWCC_FEEDBACK_INTERVAL, | |
| PROP_UPDATE_NTP64_HEADER_EXT, | |
| PROP_TIMEOUT_INACTIVE_SOURCES, | |
| PROP_LAST, | |
| }; | |
| static GParamSpec *properties[PROP_LAST]; | |
| /* update average packet size */ | |
| #define INIT_AVG(avg, val) \ | |
| (avg) = (val); | |
| #define UPDATE_AVG(avg, val) \ | |
| if ((avg) == 0) \ | |
| (avg) = (val); \ | |
| else \ | |
| (avg) = ((val) + (15 * (avg))) >> 4; | |
| /* GObject vmethods */ | |
| static void rtp_session_finalize (GObject * object); | |
| static void rtp_session_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec); | |
| static void rtp_session_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec); | |
| static gboolean rtp_session_send_rtcp (RTPSession * sess, | |
| GstClockTime max_delay); | |
| static gboolean rtp_session_send_rtcp_with_deadline (RTPSession * sess, | |
| GstClockTime deadline); | |
| static guint rtp_session_signals[LAST_SIGNAL] = { 0 }; | |
| G_DEFINE_TYPE (RTPSession, rtp_session, G_TYPE_OBJECT); | |
| static guint32 rtp_session_create_new_ssrc (RTPSession * sess); | |
| static RTPSource *obtain_source (RTPSession * sess, guint32 ssrc, | |
| gboolean * created, RTPPacketInfo * pinfo, gboolean rtp); | |
| static RTPSource *obtain_internal_source (RTPSession * sess, | |
| guint32 ssrc, gboolean * created, GstClockTime current_time); | |
| static GstFlowReturn rtp_session_schedule_bye_locked (RTPSession * sess, | |
| GstClockTime current_time); | |
| static GstClockTime calculate_rtcp_interval (RTPSession * sess, | |
| gboolean deterministic, gboolean first); | |
| static gboolean | |
| accumulate_trues (GSignalInvocationHint * ihint, GValue * return_accu, | |
| const GValue * handler_return, gpointer data) | |
| { | |
| if (g_value_get_boolean (handler_return)) | |
| g_value_set_boolean (return_accu, TRUE); | |
| return TRUE; | |
| } | |
| static void | |
| rtp_session_class_init (RTPSessionClass * klass) | |
| { | |
| GObjectClass *gobject_class; | |
| gobject_class = (GObjectClass *) klass; | |
| gobject_class->finalize = rtp_session_finalize; | |
| gobject_class->set_property = rtp_session_set_property; | |
| gobject_class->get_property = rtp_session_get_property; | |
| /** | |
| * RTPSession::get-source-by-ssrc: | |
| * @session: the object which received the signal | |
| * @ssrc: the SSRC of the RTPSource | |
| * | |
| * Request the #RTPSource object with SSRC @ssrc in @session. | |
| */ | |
| rtp_session_signals[SIGNAL_GET_SOURCE_BY_SSRC] = | |
| g_signal_new ("get-source-by-ssrc", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (RTPSessionClass, | |
| get_source_by_ssrc), NULL, NULL, NULL, | |
| RTP_TYPE_SOURCE, 1, G_TYPE_UINT); | |
| /** | |
| * RTPSession::on-new-ssrc: | |
| * @session: the object which received the signal | |
| * @src: the new RTPSource | |
| * | |
| * Notify of a new SSRC that entered @session. | |
| */ | |
| rtp_session_signals[SIGNAL_ON_NEW_SSRC] = | |
| g_signal_new ("on-new-ssrc", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_new_ssrc), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-ssrc-collision: | |
| * @session: the object which received the signal | |
| * @src: the #RTPSource that caused a collision | |
| * | |
| * Notify when we have an SSRC collision | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SSRC_COLLISION] = | |
| g_signal_new ("on-ssrc-collision", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_ssrc_collision), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-ssrc-validated: | |
| * @session: the object which received the signal | |
| * @src: the new validated RTPSource | |
| * | |
| * Notify of a new SSRC that became validated. | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SSRC_VALIDATED] = | |
| g_signal_new ("on-ssrc-validated", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_ssrc_validated), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-ssrc-active: | |
| * @session: the object which received the signal | |
| * @src: the active RTPSource | |
| * | |
| * Notify of a SSRC that is active, i.e., sending RTCP. | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SSRC_ACTIVE] = | |
| g_signal_new ("on-ssrc-active", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_ssrc_active), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-ssrc-sdes: | |
| * @session: the object which received the signal | |
| * @src: the RTPSource | |
| * | |
| * Notify that a new SDES was received for SSRC. | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SSRC_SDES] = | |
| g_signal_new ("on-ssrc-sdes", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_ssrc_sdes), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-bye-ssrc: | |
| * @session: the object which received the signal | |
| * @src: the RTPSource that went away | |
| * | |
| * Notify of an SSRC that became inactive because of a BYE packet. | |
| */ | |
| rtp_session_signals[SIGNAL_ON_BYE_SSRC] = | |
| g_signal_new ("on-bye-ssrc", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_bye_ssrc), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-bye-timeout: | |
| * @session: the object which received the signal | |
| * @src: the RTPSource that timed out | |
| * | |
| * Notify of an SSRC that has timed out because of BYE | |
| */ | |
| rtp_session_signals[SIGNAL_ON_BYE_TIMEOUT] = | |
| g_signal_new ("on-bye-timeout", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_bye_timeout), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-timeout: | |
| * @session: the object which received the signal | |
| * @src: the RTPSource that timed out | |
| * | |
| * Notify of an SSRC that has timed out | |
| */ | |
| rtp_session_signals[SIGNAL_ON_TIMEOUT] = | |
| g_signal_new ("on-timeout", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_timeout), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-sender-timeout: | |
| * @session: the object which received the signal | |
| * @src: the RTPSource that timed out | |
| * | |
| * Notify of an SSRC that was a sender but timed out and became a receiver. | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SENDER_TIMEOUT] = | |
| g_signal_new ("on-sender-timeout", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_sender_timeout), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-sending-rtcp | |
| * @session: the object which received the signal | |
| * @buffer: the #GstBuffer containing the RTCP packet about to be sent | |
| * @early: %TRUE if the packet is early, %FALSE if it is regular | |
| * | |
| * This signal is emitted before sending an RTCP packet, it can be used | |
| * to add extra RTCP Packets. | |
| * | |
| * Returns: %TRUE if the RTCP buffer should NOT be suppressed, %FALSE | |
| * if suppressing it is acceptable | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SENDING_RTCP] = | |
| g_signal_new ("on-sending-rtcp", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_sending_rtcp), | |
| accumulate_trues, NULL, NULL, G_TYPE_BOOLEAN, 2, | |
| GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_BOOLEAN); | |
| /** | |
| * RTPSession::on-app-rtcp: | |
| * @session: the object which received the signal | |
| * @subtype: The subtype of the packet | |
| * @ssrc: The SSRC/CSRC of the packet | |
| * @name: The name of the packet | |
| * @data: a #GstBuffer with the application-dependant data or %NULL if | |
| * there was no data | |
| * | |
| * Notify that a RTCP APP packet has been received | |
| */ | |
| rtp_session_signals[SIGNAL_ON_APP_RTCP] = | |
| g_signal_new ("on-app-rtcp", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_app_rtcp), | |
| NULL, NULL, NULL, G_TYPE_NONE, 4, G_TYPE_UINT, G_TYPE_UINT, | |
| G_TYPE_STRING, GST_TYPE_BUFFER); | |
| /** | |
| * RTPSession::on-feedback-rtcp: | |
| * @session: the object which received the signal | |
| * @type: Type of RTCP packet, will be %GST_RTCP_TYPE_RTPFB or | |
| * %GST_RTCP_TYPE_RTPFB | |
| * @fbtype: The type of RTCP FB packet, probably part of #GstRTCPFBType | |
| * @sender_ssrc: The SSRC of the sender | |
| * @media_ssrc: The SSRC of the media this refers to | |
| * @fci: a #GstBuffer with the FCI data from the FB packet or %NULL if | |
| * there was no FCI | |
| * | |
| * Notify that a RTCP feedback packet has been received | |
| */ | |
| rtp_session_signals[SIGNAL_ON_FEEDBACK_RTCP] = | |
| g_signal_new ("on-feedback-rtcp", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_feedback_rtcp), | |
| NULL, NULL, NULL, G_TYPE_NONE, 5, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, | |
| G_TYPE_UINT, GST_TYPE_BUFFER); | |
| /** | |
| * RTPSession::send-rtcp: | |
| * @session: the object which received the signal | |
| * @max_delay: The maximum delay after which the feedback will not be useful | |
| * anymore | |
| * | |
| * Requests that the #RTPSession initiate a new RTCP packet as soon as | |
| * possible within the requested delay. | |
| * | |
| * This sets feedback to %TRUE if not already done before. | |
| */ | |
| rtp_session_signals[SIGNAL_SEND_RTCP] = | |
| g_signal_new ("send-rtcp", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, | |
| G_STRUCT_OFFSET (RTPSessionClass, send_rtcp), NULL, NULL, | |
| NULL, G_TYPE_NONE, 1, G_TYPE_UINT64); | |
| /** | |
| * RTPSession::send-rtcp-full: | |
| * @session: the object which received the signal | |
| * @max_delay: The maximum delay after which the feedback will not be useful | |
| * anymore | |
| * | |
| * Requests that the #RTPSession initiate a new RTCP packet as soon as | |
| * possible within the requested delay. | |
| * | |
| * This sets feedback to %TRUE if not already done before. | |
| * | |
| * Returns: TRUE if the new RTCP packet could be scheduled within the | |
| * requested delay, FALSE otherwise. | |
| * | |
| * Since: 1.6 | |
| */ | |
| rtp_session_signals[SIGNAL_SEND_RTCP_FULL] = | |
| g_signal_new ("send-rtcp-full", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, | |
| G_STRUCT_OFFSET (RTPSessionClass, send_rtcp), NULL, NULL, | |
| NULL, G_TYPE_BOOLEAN, 1, G_TYPE_UINT64); | |
| /** | |
| * RTPSession::on-receiving-rtcp | |
| * @session: the object which received the signal | |
| * @buffer: the #GstBuffer containing the RTCP packet that was received | |
| * | |
| * This signal is emitted when receiving an RTCP packet before it is handled | |
| * by the session. It can be used to extract custom information from RTCP packets. | |
| * | |
| * Since: 1.6 | |
| */ | |
| rtp_session_signals[SIGNAL_ON_RECEIVING_RTCP] = | |
| g_signal_new ("on-receiving-rtcp", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_receiving_rtcp), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, | |
| GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE); | |
| /** | |
| * RTPSession::on-new-sender-ssrc: | |
| * @session: the object which received the signal | |
| * @src: the new sender RTPSource | |
| * | |
| * Notify of a new sender SSRC that entered @session. | |
| * | |
| * Since: 1.8 | |
| */ | |
| rtp_session_signals[SIGNAL_ON_NEW_SENDER_SSRC] = | |
| g_signal_new ("on-new-sender-ssrc", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_new_sender_ssrc), | |
| NULL, NULL, NULL, G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-sender-ssrc-active: | |
| * @session: the object which received the signal | |
| * @src: the active sender RTPSource | |
| * | |
| * Notify of a sender SSRC that is active, i.e., sending RTCP. | |
| * | |
| * Since: 1.8 | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SENDER_SSRC_ACTIVE] = | |
| g_signal_new ("on-sender-ssrc-active", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, | |
| on_sender_ssrc_active), NULL, NULL, NULL, | |
| G_TYPE_NONE, 1, RTP_TYPE_SOURCE); | |
| /** | |
| * RTPSession::on-sending-nack | |
| * @session: the object which received the signal | |
| * @sender_ssrc: the sender ssrc | |
| * @media_ssrc: the media ssrc | |
| * @nacks: (element-type guint16): the list of seqnum to be nacked | |
| * @buffer: the #GstBuffer containing the RTCP packet about to be sent | |
| * | |
| * This signal is emitted before NACK packets are added into the RTCP | |
| * packet. This signal can be used to override the conversion of the NACK | |
| * seqnum array into packets. This can be used if your protocol uses | |
| * different type of NACK (e.g. based on RTCP APP). | |
| * | |
| * The handler should transform the seqnum from @nacks array into packets. | |
| * @nacks seqnum must be consumed from the start. The remaining will be | |
| * rescheduled for later base on bandwidth. Only one handler will be | |
| * signalled. | |
| * | |
| * A handler may return 0 to signal that generic NACKs should be created | |
| * for this set. This can be useful if the signal is used for other purpose | |
| * or if the other type of NACK would use more space. | |
| * | |
| * Returns: the number of NACK seqnum that was consumed from @nacks. | |
| * | |
| * Since: 1.16 | |
| */ | |
| rtp_session_signals[SIGNAL_ON_SENDING_NACKS] = | |
| g_signal_new ("on-sending-nacks", G_TYPE_FROM_CLASS (klass), | |
| G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (RTPSessionClass, on_sending_nacks), | |
| g_signal_accumulator_first_wins, NULL, NULL, | |
| G_TYPE_UINT, 4, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_ARRAY, | |
| GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE); | |
| properties[PROP_INTERNAL_SSRC] = | |
| g_param_spec_uint ("internal-ssrc", "Internal SSRC", | |
| "The internal SSRC used for the session (deprecated)", | |
| 0, G_MAXUINT, 0, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_DOC_SHOW_DEFAULT); | |
| properties[PROP_INTERNAL_SOURCE] = | |
| g_param_spec_object ("internal-source", "Internal Source", | |
| "The internal source element of the session (deprecated)", | |
| RTP_TYPE_SOURCE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_BANDWIDTH] = | |
| g_param_spec_double ("bandwidth", "Bandwidth", | |
| "The bandwidth of the session in bits per second (0 for auto-discover)", | |
| 0.0, G_MAXDOUBLE, DEFAULT_BANDWIDTH, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_FRACTION] = | |
| g_param_spec_double ("rtcp-fraction", "RTCP Fraction", | |
| "The fraction of the bandwidth used for RTCP in bits per second (or as a real fraction of the RTP bandwidth if < 1)", | |
| 0.0, G_MAXDOUBLE, DEFAULT_RTCP_FRACTION, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_RR_BANDWIDTH] = | |
| g_param_spec_int ("rtcp-rr-bandwidth", "RTCP RR bandwidth", | |
| "The RTCP bandwidth used for receivers in bits per second (-1 = default)", | |
| -1, G_MAXINT, DEFAULT_RTCP_RR_BANDWIDTH, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_RS_BANDWIDTH] = | |
| g_param_spec_int ("rtcp-rs-bandwidth", "RTCP RS bandwidth", | |
| "The RTCP bandwidth used for senders in bits per second (-1 = default)", | |
| -1, G_MAXINT, DEFAULT_RTCP_RS_BANDWIDTH, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_MTU] = | |
| g_param_spec_uint ("rtcp-mtu", "RTCP MTU", | |
| "The maximum size of the RTCP packets", | |
| 16, G_MAXINT16, DEFAULT_RTCP_MTU, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_SDES] = | |
| g_param_spec_boxed ("sdes", "SDES", | |
| "The SDES items of this session", | |
| GST_TYPE_STRUCTURE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | |
| | GST_PARAM_DOC_SHOW_DEFAULT); | |
| properties[PROP_NUM_SOURCES] = | |
| g_param_spec_uint ("num-sources", "Num Sources", | |
| "The number of sources in the session", 0, G_MAXUINT, | |
| DEFAULT_NUM_SOURCES, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_NUM_ACTIVE_SOURCES] = | |
| g_param_spec_uint ("num-active-sources", "Num Active Sources", | |
| "The number of active sources in the session", 0, G_MAXUINT, | |
| DEFAULT_NUM_ACTIVE_SOURCES, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); | |
| /** | |
| * RTPSource:sources | |
| * | |
| * Get a GValue Array of all sources in the session. | |
| * | |
| * ## Getting the #RTPSources of a session | |
| * | |
| * ``` C | |
| * { | |
| * GValueArray *arr; | |
| * GValue *val; | |
| * guint i; | |
| * | |
| * g_object_get (sess, "sources", &arr, NULL); | |
| * | |
| * for (i = 0; i < arr->n_values; i++) { | |
| * RTPSource *source; | |
| * | |
| * val = g_value_array_get_nth (arr, i); | |
| * source = g_value_get_object (val); | |
| * } | |
| * g_value_array_free (arr); | |
| * } | |
| * ``` | |
| */ | |
| properties[PROP_SOURCES] = | |
| g_param_spec_boxed ("sources", "Sources", | |
| "An array of all known sources in the session", | |
| G_TYPE_VALUE_ARRAY, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_FAVOR_NEW] = | |
| g_param_spec_boolean ("favor-new", "Favor new sources", | |
| "Resolve SSRC conflict in favor of new sources", DEFAULT_FAVOR_NEW, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_MIN_INTERVAL] = | |
| g_param_spec_uint64 ("rtcp-min-interval", "Minimum RTCP interval", | |
| "Minimum interval between Regular RTCP packet (in ns)", | |
| 0, G_MAXUINT64, DEFAULT_RTCP_MIN_INTERVAL, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_FEEDBACK_RETENTION_WINDOW] = | |
| g_param_spec_uint64 ("rtcp-feedback-retention-window", | |
| "RTCP Feedback retention window", | |
| "Duration during which RTCP Feedback packets are retained (in ns)", | |
| 0, G_MAXUINT64, DEFAULT_RTCP_FEEDBACK_RETENTION_WINDOW, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_IMMEDIATE_FEEDBACK_THRESHOLD] = | |
| g_param_spec_uint ("rtcp-immediate-feedback-threshold", | |
| "RTCP Immediate Feedback threshold", | |
| "The maximum number of members of a RTP session for which immediate" | |
| " feedback is used (DEPRECATED: has no effect and is not needed)", | |
| 0, G_MAXUINT, DEFAULT_RTCP_IMMEDIATE_FEEDBACK_THRESHOLD, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_DEPRECATED); | |
| properties[PROP_PROBATION] = | |
| g_param_spec_uint ("probation", "Number of probations", | |
| "Consecutive packet sequence numbers to accept the source", | |
| 0, G_MAXUINT, DEFAULT_PROBATION, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_MAX_DROPOUT_TIME] = | |
| g_param_spec_uint ("max-dropout-time", "Max dropout time", | |
| "The maximum time (milliseconds) of missing packets tolerated.", | |
| 0, G_MAXUINT, DEFAULT_MAX_DROPOUT_TIME, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_MAX_MISORDER_TIME] = | |
| g_param_spec_uint ("max-misorder-time", "Max misorder time", | |
| "The maximum time (milliseconds) of misordered packets tolerated.", | |
| 0, G_MAXUINT, DEFAULT_MAX_MISORDER_TIME, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| /** | |
| * RTPSession:stats: | |
| * | |
| * Various session statistics. This property returns a GstStructure | |
| * with name application/x-rtp-session-stats with the following fields: | |
| * | |
| * * "rtx-drop-count" G_TYPE_UINT The number of retransmission events | |
| * dropped (due to bandwidth constraints) | |
| * * "sent-nack-count" G_TYPE_UINT Number of NACKs sent | |
| * * "recv-nack-count" G_TYPE_UINT Number of NACKs received | |
| * * "source-stats" G_TYPE_BOXED GValueArray of #RTPSource:stats for all | |
| * RTP sources (Since 1.8) | |
| * | |
| * Since: 1.4 | |
| */ | |
| properties[PROP_STATS] = | |
| g_param_spec_boxed ("stats", "Statistics", | |
| "Various statistics", GST_TYPE_STRUCTURE, | |
| G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTP_PROFILE] = | |
| g_param_spec_enum ("rtp-profile", "RTP Profile", | |
| "RTP profile to use for this session", GST_TYPE_RTP_PROFILE, | |
| DEFAULT_RTP_PROFILE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| properties[PROP_RTCP_REDUCED_SIZE] = | |
| g_param_spec_boolean ("rtcp-reduced-size", "RTCP Reduced Size", | |
| "Use Reduced Size RTCP for feedback packets", | |
| DEFAULT_RTCP_REDUCED_SIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| /** | |
| * RTPSession:disable-sr-timestamp: | |
| * | |
| * Whether sender reports should be timestamped. | |
| * | |
| * Since: 1.16 | |
| */ | |
| properties[PROP_RTCP_DISABLE_SR_TIMESTAMP] = | |
| g_param_spec_boolean ("disable-sr-timestamp", | |
| "Disable Sender Report Timestamp", | |
| "Whether sender reports should be timestamped", | |
| DEFAULT_RTCP_DISABLE_SR_TIMESTAMP, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| /** | |
| * RTPSession:twcc-feedback-interval: | |
| * | |
| * The interval to send TWCC reports on. | |
| * This overrides the default behavior of sending reports | |
| * based on marker-bits. | |
| * | |
| * Since: 1.20 | |
| */ | |
| properties[PROP_TWCC_FEEDBACK_INTERVAL] = | |
| g_param_spec_uint64 ("twcc-feedback-interval", | |
| "TWCC Feedback Interval", | |
| "The interval to send TWCC reports on", | |
| 0, G_MAXUINT64, DEFAULT_TWCC_FEEDBACK_INTERVAL, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| /** | |
| * RTPSession:update-ntp64-header-ext: | |
| * | |
| * Whether RTP NTP header extension should be updated with actual | |
| * NTP time. If not, use the NTP time from buffer timestamp metadata | |
| * | |
| * Since: 1.22 | |
| */ | |
| properties[PROP_UPDATE_NTP64_HEADER_EXT] = | |
| g_param_spec_boolean ("update-ntp64-header-ext", | |
| "Update NTP-64 RTP Header Extension", | |
| "Whether RTP NTP header extension should be updated with actual NTP time", | |
| DEFAULT_UPDATE_NTP64_HEADER_EXT, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| /** | |
| * RTPSession:timeout-inactive-sources: | |
| * | |
| * Whether inactive sources should be timed out | |
| * | |
| * Since: 1.24 | |
| */ | |
| properties[PROP_TIMEOUT_INACTIVE_SOURCES] = | |
| g_param_spec_boolean ("timeout-inactive-sources", | |
| "Time out inactive sources", | |
| "Whether sources that don't receive RTP or RTCP packets for longer " | |
| "than 5x RTCP interval should be removed", | |
| DEFAULT_TIMEOUT_INACTIVE_SOURCES, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); | |
| g_object_class_install_properties (gobject_class, PROP_LAST, properties); | |
| klass->get_source_by_ssrc = | |
| GST_DEBUG_FUNCPTR (rtp_session_get_source_by_ssrc); | |
| klass->send_rtcp = GST_DEBUG_FUNCPTR (rtp_session_send_rtcp); | |
| GST_DEBUG_CATEGORY_INIT (rtp_session_debug, "rtpsession", 0, "RTP Session"); | |
| } | |
| static void | |
| rtp_session_init (RTPSession * sess) | |
| { | |
| gint i; | |
| gchar *str; | |
| g_mutex_init (&sess->lock); | |
| sess->key = g_random_int (); | |
| sess->mask_idx = 0; | |
| sess->mask = 0; | |
| /* TODO: We currently only use the first hash table but this is the | |
| * beginning of an implementation for RFC2762 | |
| for (i = 0; i < 32; i++) { | |
| */ | |
| for (i = 0; i < 1; i++) { | |
| sess->ssrcs[i] = | |
| g_hash_table_new_full (NULL, NULL, NULL, | |
| (GDestroyNotify) g_object_unref); | |
| } | |
| rtp_stats_init_defaults (&sess->stats); | |
| INIT_AVG (sess->stats.avg_rtcp_packet_size, 100); | |
| rtp_stats_set_min_interval (&sess->stats, | |
| (gdouble) DEFAULT_RTCP_MIN_INTERVAL / GST_SECOND); | |
| sess->recalc_bandwidth = TRUE; | |
| sess->bandwidth = DEFAULT_BANDWIDTH; | |
| sess->rtcp_bandwidth = DEFAULT_RTCP_FRACTION; | |
| sess->rtcp_rr_bandwidth = DEFAULT_RTCP_RR_BANDWIDTH; | |
| sess->rtcp_rs_bandwidth = DEFAULT_RTCP_RS_BANDWIDTH; | |
| /* default UDP header length */ | |
| sess->header_len = UDP_IP_HEADER_OVERHEAD; | |
| sess->mtu = DEFAULT_RTCP_MTU; | |
| sess->update_ntp64_header_ext = DEFAULT_UPDATE_NTP64_HEADER_EXT; | |
| sess->timeout_inactive_sources = DEFAULT_TIMEOUT_INACTIVE_SOURCES; | |
| sess->probation = DEFAULT_PROBATION; | |
| sess->max_dropout_time = DEFAULT_MAX_DROPOUT_TIME; | |
| sess->max_misorder_time = DEFAULT_MAX_MISORDER_TIME; | |
| sess->favor_new = DEFAULT_FAVOR_NEW; | |
| /* some default SDES entries */ | |
| sess->sdes = gst_structure_new_empty ("application/x-rtp-source-sdes"); | |
| /* we do not want to leak details like the username or hostname here */ | |
| str = g_strdup_printf ("user%u@host-%x", g_random_int (), g_random_int ()); | |
| gst_structure_set (sess->sdes, "cname", G_TYPE_STRING, str, NULL); | |
| g_free (str); | |
| #if 0 | |
| /* we do not want to leak the user's real name here */ | |
| str = g_strdup_printf ("Anon%u", g_random_int ()); | |
| gst_structure_set (sdes, "name", G_TYPE_STRING, str, NULL); | |
| g_free (str); | |
| #endif | |
| gst_structure_set (sess->sdes, "tool", G_TYPE_STRING, "GStreamer", NULL); | |
| /* this is the SSRC we suggest */ | |
| sess->suggested_ssrc = rtp_session_create_new_ssrc (sess); | |
| sess->internal_ssrc_set = FALSE; | |
| sess->first_rtcp = TRUE; | |
| sess->next_rtcp_check_time = GST_CLOCK_TIME_NONE; | |
| sess->last_rtcp_check_time = GST_CLOCK_TIME_NONE; | |
| sess->last_rtcp_send_time = GST_CLOCK_TIME_NONE; | |
| sess->last_rtcp_interval = GST_CLOCK_TIME_NONE; | |
| sess->next_early_rtcp_time = GST_CLOCK_TIME_NONE; | |
| sess->rtcp_feedback_retention_window = DEFAULT_RTCP_FEEDBACK_RETENTION_WINDOW; | |
| sess->rtcp_immediate_feedback_threshold = | |
| DEFAULT_RTCP_IMMEDIATE_FEEDBACK_THRESHOLD; | |
| sess->rtp_profile = DEFAULT_RTP_PROFILE; | |
| sess->reduced_size_rtcp = DEFAULT_RTCP_REDUCED_SIZE; | |
| sess->timestamp_sender_reports = !DEFAULT_RTCP_DISABLE_SR_TIMESTAMP; | |
| sess->is_doing_ptp = TRUE; | |
| sess->twcc = rtp_twcc_manager_new (sess->mtu); | |
| sess->twcc_stats = rtp_twcc_stats_new (); | |
| } | |
| static void | |
| rtp_session_finalize (GObject * object) | |
| { | |
| RTPSession *sess; | |
| gint i; | |
| sess = RTP_SESSION_CAST (object); | |
| gst_structure_free (sess->sdes); | |
| g_list_free_full (sess->conflicting_addresses, | |
| (GDestroyNotify) rtp_conflicting_address_free); | |
| /* TODO: Change this again when implementing RFC 2762 | |
| * for (i = 0; i < 32; i++) | |
| */ | |
| for (i = 0; i < 1; i++) | |
| g_hash_table_destroy (sess->ssrcs[i]); | |
| g_object_unref (sess->twcc); | |
| rtp_twcc_stats_free (sess->twcc_stats); | |
| g_mutex_clear (&sess->lock); | |
| G_OBJECT_CLASS (rtp_session_parent_class)->finalize (object); | |
| } | |
| static void | |
| copy_source (gpointer key, RTPSource * source, GValueArray * arr) | |
| { | |
| GValue value = { 0 }; | |
| g_value_init (&value, RTP_TYPE_SOURCE); | |
| g_value_take_object (&value, source); | |
| /* copies the value */ | |
| g_value_array_append (arr, &value); | |
| } | |
| static GValueArray * | |
| rtp_session_create_sources (RTPSession * sess) | |
| { | |
| GValueArray *res; | |
| guint size; | |
| RTP_SESSION_LOCK (sess); | |
| /* get number of elements in the table */ | |
| size = g_hash_table_size (sess->ssrcs[sess->mask_idx]); | |
| /* create the result value array */ | |
| res = g_value_array_new (size); | |
| /* and copy all values into the array */ | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], (GHFunc) copy_source, res); | |
| RTP_SESSION_UNLOCK (sess); | |
| return res; | |
| } | |
| static void | |
| create_source_stats (gpointer key, RTPSource * source, GValueArray * arr) | |
| { | |
| GValue *value; | |
| GstStructure *s; | |
| g_object_get (source, "stats", &s, NULL); | |
| g_value_array_append (arr, NULL); | |
| value = g_value_array_get_nth (arr, arr->n_values - 1); | |
| g_value_init (value, GST_TYPE_STRUCTURE); | |
| g_value_take_boxed (value, s); | |
| } | |
| static GstStructure * | |
| rtp_session_create_stats (RTPSession * sess) | |
| { | |
| GstStructure *s; | |
| GValueArray *source_stats; | |
| GValue source_stats_v = G_VALUE_INIT; | |
| guint size; | |
| RTP_SESSION_LOCK (sess); | |
| s = gst_structure_new ("application/x-rtp-session-stats", | |
| "rtx-drop-count", G_TYPE_UINT, sess->stats.nacks_dropped, | |
| "sent-nack-count", G_TYPE_UINT, sess->stats.nacks_sent, | |
| "recv-nack-count", G_TYPE_UINT, sess->stats.nacks_received, NULL); | |
| size = g_hash_table_size (sess->ssrcs[sess->mask_idx]); | |
| source_stats = g_value_array_new (size); | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) create_source_stats, source_stats); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_value_init (&source_stats_v, G_TYPE_VALUE_ARRAY); | |
| g_value_take_boxed (&source_stats_v, source_stats); | |
| gst_structure_take_value (s, "source-stats", &source_stats_v); | |
| return s; | |
| } | |
| static void | |
| rtp_session_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec) | |
| { | |
| RTPSession *sess; | |
| sess = RTP_SESSION (object); | |
| switch (prop_id) { | |
| case PROP_INTERNAL_SSRC: | |
| RTP_SESSION_LOCK (sess); | |
| sess->suggested_ssrc = g_value_get_uint (value); | |
| sess->internal_ssrc_set = TRUE; | |
| sess->internal_ssrc_from_caps_or_property = TRUE; | |
| RTP_SESSION_UNLOCK (sess); | |
| if (sess->callbacks.reconfigure) | |
| sess->callbacks.reconfigure (sess, sess->reconfigure_user_data); | |
| break; | |
| case PROP_BANDWIDTH: | |
| RTP_SESSION_LOCK (sess); | |
| sess->bandwidth = g_value_get_double (value); | |
| sess->recalc_bandwidth = TRUE; | |
| RTP_SESSION_UNLOCK (sess); | |
| break; | |
| case PROP_RTCP_FRACTION: | |
| RTP_SESSION_LOCK (sess); | |
| sess->rtcp_bandwidth = g_value_get_double (value); | |
| sess->recalc_bandwidth = TRUE; | |
| RTP_SESSION_UNLOCK (sess); | |
| break; | |
| case PROP_RTCP_RR_BANDWIDTH: | |
| RTP_SESSION_LOCK (sess); | |
| sess->rtcp_rr_bandwidth = g_value_get_int (value); | |
| sess->recalc_bandwidth = TRUE; | |
| RTP_SESSION_UNLOCK (sess); | |
| break; | |
| case PROP_RTCP_RS_BANDWIDTH: | |
| RTP_SESSION_LOCK (sess); | |
| sess->rtcp_rs_bandwidth = g_value_get_int (value); | |
| sess->recalc_bandwidth = TRUE; | |
| RTP_SESSION_UNLOCK (sess); | |
| break; | |
| case PROP_RTCP_MTU: | |
| sess->mtu = g_value_get_uint (value); | |
| rtp_twcc_manager_set_mtu (sess->twcc, sess->mtu); | |
| break; | |
| case PROP_SDES: | |
| rtp_session_set_sdes_struct (sess, g_value_get_boxed (value)); | |
| break; | |
| case PROP_FAVOR_NEW: | |
| sess->favor_new = g_value_get_boolean (value); | |
| break; | |
| case PROP_RTCP_MIN_INTERVAL: | |
| rtp_stats_set_min_interval (&sess->stats, | |
| (gdouble) g_value_get_uint64 (value) / GST_SECOND); | |
| /* trigger reconsideration */ | |
| RTP_SESSION_LOCK (sess); | |
| sess->next_rtcp_check_time = 0; | |
| RTP_SESSION_UNLOCK (sess); | |
| if (sess->callbacks.reconsider) | |
| sess->callbacks.reconsider (sess, sess->reconsider_user_data); | |
| break; | |
| case PROP_RTCP_FEEDBACK_RETENTION_WINDOW: | |
| sess->rtcp_feedback_retention_window = g_value_get_uint64 (value); | |
| break; | |
| case PROP_RTCP_IMMEDIATE_FEEDBACK_THRESHOLD: | |
| sess->rtcp_immediate_feedback_threshold = g_value_get_uint (value); | |
| break; | |
| case PROP_PROBATION: | |
| sess->probation = g_value_get_uint (value); | |
| break; | |
| case PROP_MAX_DROPOUT_TIME: | |
| sess->max_dropout_time = g_value_get_uint (value); | |
| break; | |
| case PROP_MAX_MISORDER_TIME: | |
| sess->max_misorder_time = g_value_get_uint (value); | |
| break; | |
| case PROP_RTP_PROFILE: | |
| sess->rtp_profile = g_value_get_enum (value); | |
| /* trigger reconsideration */ | |
| RTP_SESSION_LOCK (sess); | |
| sess->next_rtcp_check_time = 0; | |
| RTP_SESSION_UNLOCK (sess); | |
| if (sess->callbacks.reconsider) | |
| sess->callbacks.reconsider (sess, sess->reconsider_user_data); | |
| break; | |
| case PROP_RTCP_REDUCED_SIZE: | |
| sess->reduced_size_rtcp = g_value_get_boolean (value); | |
| break; | |
| case PROP_RTCP_DISABLE_SR_TIMESTAMP: | |
| sess->timestamp_sender_reports = !g_value_get_boolean (value); | |
| break; | |
| case PROP_TWCC_FEEDBACK_INTERVAL: | |
| rtp_twcc_manager_set_feedback_interval (sess->twcc, | |
| g_value_get_uint64 (value)); | |
| break; | |
| case PROP_UPDATE_NTP64_HEADER_EXT: | |
| sess->update_ntp64_header_ext = g_value_get_boolean (value); | |
| break; | |
| case PROP_TIMEOUT_INACTIVE_SOURCES: | |
| sess->timeout_inactive_sources = g_value_get_boolean (value); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| static void | |
| rtp_session_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec) | |
| { | |
| RTPSession *sess; | |
| sess = RTP_SESSION (object); | |
| switch (prop_id) { | |
| case PROP_INTERNAL_SSRC: | |
| g_value_set_uint (value, rtp_session_suggest_ssrc (sess, NULL)); | |
| break; | |
| case PROP_INTERNAL_SOURCE: | |
| /* FIXME, return a random source */ | |
| g_value_set_object (value, NULL); | |
| break; | |
| case PROP_BANDWIDTH: | |
| g_value_set_double (value, sess->bandwidth); | |
| break; | |
| case PROP_RTCP_FRACTION: | |
| g_value_set_double (value, sess->rtcp_bandwidth); | |
| break; | |
| case PROP_RTCP_RR_BANDWIDTH: | |
| g_value_set_int (value, sess->rtcp_rr_bandwidth); | |
| break; | |
| case PROP_RTCP_RS_BANDWIDTH: | |
| g_value_set_int (value, sess->rtcp_rs_bandwidth); | |
| break; | |
| case PROP_RTCP_MTU: | |
| g_value_set_uint (value, sess->mtu); | |
| break; | |
| case PROP_SDES: | |
| g_value_take_boxed (value, rtp_session_get_sdes_struct (sess)); | |
| break; | |
| case PROP_NUM_SOURCES: | |
| g_value_set_uint (value, rtp_session_get_num_sources (sess)); | |
| break; | |
| case PROP_NUM_ACTIVE_SOURCES: | |
| g_value_set_uint (value, rtp_session_get_num_active_sources (sess)); | |
| break; | |
| case PROP_SOURCES: | |
| g_value_take_boxed (value, rtp_session_create_sources (sess)); | |
| break; | |
| case PROP_FAVOR_NEW: | |
| g_value_set_boolean (value, sess->favor_new); | |
| break; | |
| case PROP_RTCP_MIN_INTERVAL: | |
| g_value_set_uint64 (value, sess->stats.min_interval * GST_SECOND); | |
| break; | |
| case PROP_RTCP_FEEDBACK_RETENTION_WINDOW: | |
| g_value_set_uint64 (value, sess->rtcp_feedback_retention_window); | |
| break; | |
| case PROP_RTCP_IMMEDIATE_FEEDBACK_THRESHOLD: | |
| g_value_set_uint (value, sess->rtcp_immediate_feedback_threshold); | |
| break; | |
| case PROP_PROBATION: | |
| g_value_set_uint (value, sess->probation); | |
| break; | |
| case PROP_MAX_DROPOUT_TIME: | |
| g_value_set_uint (value, sess->max_dropout_time); | |
| break; | |
| case PROP_MAX_MISORDER_TIME: | |
| g_value_set_uint (value, sess->max_misorder_time); | |
| break; | |
| case PROP_STATS: | |
| g_value_take_boxed (value, rtp_session_create_stats (sess)); | |
| break; | |
| case PROP_RTP_PROFILE: | |
| g_value_set_enum (value, sess->rtp_profile); | |
| break; | |
| case PROP_RTCP_REDUCED_SIZE: | |
| g_value_set_boolean (value, sess->reduced_size_rtcp); | |
| break; | |
| case PROP_RTCP_DISABLE_SR_TIMESTAMP: | |
| g_value_set_boolean (value, !sess->timestamp_sender_reports); | |
| break; | |
| case PROP_TWCC_FEEDBACK_INTERVAL: | |
| g_value_set_uint64 (value, | |
| rtp_twcc_manager_get_feedback_interval (sess->twcc)); | |
| break; | |
| case PROP_UPDATE_NTP64_HEADER_EXT: | |
| g_value_set_boolean (value, sess->update_ntp64_header_ext); | |
| break; | |
| case PROP_TIMEOUT_INACTIVE_SOURCES: | |
| g_value_set_boolean (value, sess->timeout_inactive_sources); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| static void | |
| on_new_ssrc (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_NEW_SSRC], 0, source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_ssrc_collision (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SSRC_COLLISION], 0, | |
| source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_ssrc_validated (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SSRC_VALIDATED], 0, | |
| source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_ssrc_active (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SSRC_ACTIVE], 0, source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_ssrc_sdes (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| GST_DEBUG ("SDES changed for SSRC %08x", source->ssrc); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SSRC_SDES], 0, source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_bye_ssrc (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_BYE_SSRC], 0, source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_bye_timeout (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_BYE_TIMEOUT], 0, source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_timeout (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_TIMEOUT], 0, source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_sender_timeout (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SENDER_TIMEOUT], 0, | |
| source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_new_sender_ssrc (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_NEW_SENDER_SSRC], 0, | |
| source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| static void | |
| on_sender_ssrc_active (RTPSession * sess, RTPSource * source) | |
| { | |
| g_object_ref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SENDER_SSRC_ACTIVE], 0, | |
| source); | |
| RTP_SESSION_LOCK (sess); | |
| g_object_unref (source); | |
| } | |
| /** | |
| * rtp_session_new: | |
| * | |
| * Create a new session object. | |
| * | |
| * Returns: a new #RTPSession. g_object_unref() after usage. | |
| */ | |
| RTPSession * | |
| rtp_session_new (void) | |
| { | |
| RTPSession *sess; | |
| sess = g_object_new (RTP_TYPE_SESSION, NULL); | |
| return sess; | |
| } | |
| /** | |
| * rtp_session_reset: | |
| * @sess: an #RTPSession | |
| * | |
| * Reset the sources of @sess. | |
| */ | |
| void | |
| rtp_session_reset (RTPSession * sess) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| RTP_SESSION_LOCK (sess); | |
| /* remove all sources */ | |
| g_hash_table_remove_all (sess->ssrcs[sess->mask_idx]); | |
| sess->total_sources = 0; | |
| sess->stats.sender_sources = 0; | |
| sess->stats.internal_sender_sources = 0; | |
| sess->stats.internal_sources = 0; | |
| sess->stats.active_sources = 0; | |
| sess->generation = 0; | |
| sess->first_rtcp = TRUE; | |
| sess->next_rtcp_check_time = GST_CLOCK_TIME_NONE; | |
| sess->last_rtcp_check_time = GST_CLOCK_TIME_NONE; | |
| sess->last_rtcp_send_time = GST_CLOCK_TIME_NONE; | |
| sess->last_rtcp_interval = GST_CLOCK_TIME_NONE; | |
| sess->next_early_rtcp_time = GST_CLOCK_TIME_NONE; | |
| sess->scheduled_bye = FALSE; | |
| /* reset session stats */ | |
| sess->stats.bye_members = 0; | |
| sess->stats.nacks_dropped = 0; | |
| sess->stats.nacks_sent = 0; | |
| sess->stats.nacks_received = 0; | |
| sess->is_doing_ptp = TRUE; | |
| g_list_free_full (sess->conflicting_addresses, | |
| (GDestroyNotify) rtp_conflicting_address_free); | |
| sess->conflicting_addresses = NULL; | |
| RTP_SESSION_UNLOCK (sess); | |
| } | |
| /** | |
| * rtp_session_set_callbacks: | |
| * @sess: an #RTPSession | |
| * @callbacks: callbacks to configure | |
| * @user_data: user data passed in the callbacks | |
| * | |
| * Configure a set of callbacks to be notified of actions. | |
| */ | |
| void | |
| rtp_session_set_callbacks (RTPSession * sess, RTPSessionCallbacks * callbacks, | |
| gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| if (callbacks->process_rtp) { | |
| sess->callbacks.process_rtp = callbacks->process_rtp; | |
| sess->process_rtp_user_data = user_data; | |
| } | |
| if (callbacks->send_rtp) { | |
| sess->callbacks.send_rtp = callbacks->send_rtp; | |
| sess->send_rtp_user_data = user_data; | |
| } | |
| if (callbacks->send_rtcp) { | |
| sess->callbacks.send_rtcp = callbacks->send_rtcp; | |
| sess->send_rtcp_user_data = user_data; | |
| } | |
| if (callbacks->sync_rtcp) { | |
| sess->callbacks.sync_rtcp = callbacks->sync_rtcp; | |
| sess->sync_rtcp_user_data = user_data; | |
| } | |
| if (callbacks->caps) { | |
| sess->callbacks.caps = callbacks->caps; | |
| sess->caps_user_data = user_data; | |
| } | |
| if (callbacks->reconsider) { | |
| sess->callbacks.reconsider = callbacks->reconsider; | |
| sess->reconsider_user_data = user_data; | |
| } | |
| if (callbacks->request_key_unit) { | |
| sess->callbacks.request_key_unit = callbacks->request_key_unit; | |
| sess->request_key_unit_user_data = user_data; | |
| } | |
| if (callbacks->request_time) { | |
| sess->callbacks.request_time = callbacks->request_time; | |
| sess->request_time_user_data = user_data; | |
| } | |
| if (callbacks->notify_nack) { | |
| sess->callbacks.notify_nack = callbacks->notify_nack; | |
| sess->notify_nack_user_data = user_data; | |
| } | |
| if (callbacks->notify_twcc) { | |
| sess->callbacks.notify_twcc = callbacks->notify_twcc; | |
| sess->notify_twcc_user_data = user_data; | |
| } | |
| if (callbacks->reconfigure) { | |
| sess->callbacks.reconfigure = callbacks->reconfigure; | |
| sess->reconfigure_user_data = user_data; | |
| } | |
| if (callbacks->notify_early_rtcp) { | |
| sess->callbacks.notify_early_rtcp = callbacks->notify_early_rtcp; | |
| sess->notify_early_rtcp_user_data = user_data; | |
| } | |
| } | |
| /** | |
| * rtp_session_set_process_rtp_callback: | |
| * @sess: an #RTPSession | |
| * @callback: callback to set | |
| * @user_data: user data passed in the callback | |
| * | |
| * Configure only the process_rtp callback to be notified of the process_rtp action. | |
| */ | |
| void | |
| rtp_session_set_process_rtp_callback (RTPSession * sess, | |
| RTPSessionProcessRTP callback, gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| sess->callbacks.process_rtp = callback; | |
| sess->process_rtp_user_data = user_data; | |
| } | |
| /** | |
| * rtp_session_set_send_rtp_callback: | |
| * @sess: an #RTPSession | |
| * @callback: callback to set | |
| * @user_data: user data passed in the callback | |
| * | |
| * Configure only the send_rtp callback to be notified of the send_rtp action. | |
| */ | |
| void | |
| rtp_session_set_send_rtp_callback (RTPSession * sess, | |
| RTPSessionSendRTP callback, gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| sess->callbacks.send_rtp = callback; | |
| sess->send_rtp_user_data = user_data; | |
| } | |
| /** | |
| * rtp_session_set_send_rtcp_callback: | |
| * @sess: an #RTPSession | |
| * @callback: callback to set | |
| * @user_data: user data passed in the callback | |
| * | |
| * Configure only the send_rtcp callback to be notified of the send_rtcp action. | |
| */ | |
| void | |
| rtp_session_set_send_rtcp_callback (RTPSession * sess, | |
| RTPSessionSendRTCP callback, gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| sess->callbacks.send_rtcp = callback; | |
| sess->send_rtcp_user_data = user_data; | |
| } | |
| /** | |
| * rtp_session_set_sync_rtcp_callback: | |
| * @sess: an #RTPSession | |
| * @callback: callback to set | |
| * @user_data: user data passed in the callback | |
| * | |
| * Configure only the sync_rtcp callback to be notified of the sync_rtcp action. | |
| */ | |
| void | |
| rtp_session_set_sync_rtcp_callback (RTPSession * sess, | |
| RTPSessionSyncRTCP callback, gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| sess->callbacks.sync_rtcp = callback; | |
| sess->sync_rtcp_user_data = user_data; | |
| } | |
| /** | |
| * rtp_session_set_caps_callback: | |
| * @sess: an #RTPSession | |
| * @callback: callback to set | |
| * @user_data: user data passed in the callback | |
| * | |
| * Configure only the clock_rate callback to be notified of the clock_rate action. | |
| */ | |
| void | |
| rtp_session_set_caps_callback (RTPSession * sess, | |
| RTPSessionCaps callback, gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| sess->callbacks.caps = callback; | |
| sess->caps_user_data = user_data; | |
| } | |
| /** | |
| * rtp_session_set_reconsider_callback: | |
| * @sess: an #RTPSession | |
| * @callback: callback to set | |
| * @user_data: user data passed in the callback | |
| * | |
| * Configure only the reconsider callback to be notified of the reconsider action. | |
| */ | |
| void | |
| rtp_session_set_reconsider_callback (RTPSession * sess, | |
| RTPSessionReconsider callback, gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| sess->callbacks.reconsider = callback; | |
| sess->reconsider_user_data = user_data; | |
| } | |
| /** | |
| * rtp_session_set_request_time_callback: | |
| * @sess: an #RTPSession | |
| * @callback: callback to set | |
| * @user_data: user data passed in the callback | |
| * | |
| * Configure only the request_time callback | |
| */ | |
| void | |
| rtp_session_set_request_time_callback (RTPSession * sess, | |
| RTPSessionRequestTime callback, gpointer user_data) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| sess->callbacks.request_time = callback; | |
| sess->request_time_user_data = user_data; | |
| } | |
| /** | |
| * rtp_session_set_bandwidth: | |
| * @sess: an #RTPSession | |
| * @bandwidth: the bandwidth allocated | |
| * | |
| * Set the session bandwidth in bits per second. | |
| */ | |
| void | |
| rtp_session_set_bandwidth (RTPSession * sess, gdouble bandwidth) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| RTP_SESSION_LOCK (sess); | |
| sess->stats.bandwidth = bandwidth; | |
| RTP_SESSION_UNLOCK (sess); | |
| } | |
| /** | |
| * rtp_session_get_bandwidth: | |
| * @sess: an #RTPSession | |
| * | |
| * Get the session bandwidth. | |
| * | |
| * Returns: the session bandwidth. | |
| */ | |
| gdouble | |
| rtp_session_get_bandwidth (RTPSession * sess) | |
| { | |
| gdouble result; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), 0); | |
| RTP_SESSION_LOCK (sess); | |
| result = sess->stats.bandwidth; | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_set_rtcp_fraction: | |
| * @sess: an #RTPSession | |
| * @bandwidth: the RTCP bandwidth | |
| * | |
| * Set the bandwidth in bits per second that should be used for RTCP | |
| * messages. | |
| */ | |
| void | |
| rtp_session_set_rtcp_fraction (RTPSession * sess, gdouble bandwidth) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| RTP_SESSION_LOCK (sess); | |
| sess->stats.rtcp_bandwidth = bandwidth; | |
| RTP_SESSION_UNLOCK (sess); | |
| } | |
| /** | |
| * rtp_session_get_rtcp_fraction: | |
| * @sess: an #RTPSession | |
| * | |
| * Get the session bandwidth used for RTCP. | |
| * | |
| * Returns: The bandwidth used for RTCP messages. | |
| */ | |
| gdouble | |
| rtp_session_get_rtcp_fraction (RTPSession * sess) | |
| { | |
| gdouble result; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), 0.0); | |
| RTP_SESSION_LOCK (sess); | |
| result = sess->stats.rtcp_bandwidth; | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_get_sdes_struct: | |
| * @sess: an #RTSPSession | |
| * | |
| * Get the SDES data as a #GstStructure | |
| * | |
| * Returns: a GstStructure with SDES items for @sess. This function returns a | |
| * copy of the SDES structure, use gst_structure_free() after usage. | |
| */ | |
| GstStructure * | |
| rtp_session_get_sdes_struct (RTPSession * sess) | |
| { | |
| GstStructure *result = NULL; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), NULL); | |
| RTP_SESSION_LOCK (sess); | |
| if (sess->sdes) | |
| result = gst_structure_copy (sess->sdes); | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| static void | |
| source_set_sdes (const gchar * key, RTPSource * source, GstStructure * sdes) | |
| { | |
| rtp_source_set_sdes_struct (source, gst_structure_copy (sdes)); | |
| } | |
| /** | |
| * rtp_session_set_sdes_struct: | |
| * @sess: an #RTSPSession | |
| * @sdes: a #GstStructure | |
| * | |
| * Set the SDES data as a #GstStructure. This function makes a copy of @sdes. | |
| */ | |
| void | |
| rtp_session_set_sdes_struct (RTPSession * sess, const GstStructure * sdes) | |
| { | |
| g_return_if_fail (sdes); | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| RTP_SESSION_LOCK (sess); | |
| if (sess->sdes) | |
| gst_structure_free (sess->sdes); | |
| sess->sdes = gst_structure_copy (sdes); | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) source_set_sdes, sess->sdes); | |
| RTP_SESSION_UNLOCK (sess); | |
| } | |
| static GstFlowReturn | |
| source_push_rtp (RTPSource * source, gpointer data, RTPSession * session) | |
| { | |
| GstFlowReturn result = GST_FLOW_OK; | |
| if (source->internal) { | |
| GST_LOG ("source %08x pushed sender RTP packet", source->ssrc); | |
| RTP_SESSION_UNLOCK (session); | |
| if (session->callbacks.send_rtp) | |
| result = | |
| session->callbacks.send_rtp (session, source, data, | |
| session->send_rtp_user_data); | |
| else { | |
| gst_mini_object_unref (GST_MINI_OBJECT_CAST (data)); | |
| } | |
| } else { | |
| GST_LOG ("source %08x pushed receiver RTP packet", source->ssrc); | |
| RTP_SESSION_UNLOCK (session); | |
| if (session->callbacks.process_rtp) | |
| result = | |
| session->callbacks.process_rtp (session, source, | |
| GST_BUFFER_CAST (data), session->process_rtp_user_data); | |
| else | |
| gst_buffer_unref (GST_BUFFER_CAST (data)); | |
| } | |
| RTP_SESSION_LOCK (session); | |
| return result; | |
| } | |
| static GstCaps * | |
| source_caps (RTPSource * source, guint8 pt, RTPSession * session) | |
| { | |
| GstCaps *result = NULL; | |
| RTP_SESSION_UNLOCK (session); | |
| if (session->callbacks.caps) | |
| result = session->callbacks.caps (session, pt, session->caps_user_data); | |
| RTP_SESSION_LOCK (session); | |
| GST_DEBUG ("got caps %" GST_PTR_FORMAT " for pt %d", result, pt); | |
| return result; | |
| } | |
| static RTPSourceCallbacks callbacks = { | |
| (RTPSourcePushRTP) source_push_rtp, | |
| (RTPSourceCaps) source_caps, | |
| }; | |
| /** | |
| * rtp_session_find_conflicting_address: | |
| * @session: The session the packet came in | |
| * @address: address to check for | |
| * @time: The time when the packet that is possibly in conflict arrived | |
| * | |
| * Checks if an address which has a conflict is already known. If it is | |
| * a known conflict, remember the time | |
| * | |
| * Returns: TRUE if it was a known conflict, FALSE otherwise | |
| */ | |
| static gboolean | |
| rtp_session_find_conflicting_address (RTPSession * session, | |
| GSocketAddress * address, GstClockTime time) | |
| { | |
| return find_conflicting_address (session->conflicting_addresses, address, | |
| time); | |
| } | |
| /** | |
| * rtp_session_add_conflicting_address: | |
| * @session: The session the packet came in | |
| * @address: address to remember | |
| * @time: The time when the packet that is in conflict arrived | |
| * | |
| * Adds a new conflict address | |
| */ | |
| static void | |
| rtp_session_add_conflicting_address (RTPSession * sess, | |
| GSocketAddress * address, GstClockTime time) | |
| { | |
| sess->conflicting_addresses = | |
| add_conflicting_address (sess->conflicting_addresses, address, time); | |
| } | |
| static void | |
| rtp_session_have_conflict (RTPSession * sess, RTPSource * source, | |
| GSocketAddress * address, GstClockTime current_time) | |
| { | |
| guint32 ssrc = rtp_source_get_ssrc (source); | |
| /* Its a new collision, lets change our SSRC */ | |
| rtp_session_add_conflicting_address (sess, address, current_time); | |
| /* mark the source BYE */ | |
| rtp_source_mark_bye (source, "SSRC Collision"); | |
| /* if we were suggesting this SSRC, change to something else */ | |
| if (sess->suggested_ssrc == ssrc) { | |
| sess->suggested_ssrc = rtp_session_create_new_ssrc (sess); | |
| sess->internal_ssrc_set = TRUE; | |
| } | |
| on_ssrc_collision (sess, source); | |
| rtp_session_schedule_bye_locked (sess, current_time); | |
| } | |
| static gboolean | |
| check_collision (RTPSession * sess, RTPSource * source, | |
| RTPPacketInfo * pinfo, gboolean rtp) | |
| { | |
| guint32 ssrc; | |
| /* If we have no pinfo address, we can't do collision checking */ | |
| if (!pinfo->address) | |
| return FALSE; | |
| ssrc = rtp_source_get_ssrc (source); | |
| if (!source->internal) { | |
| GSocketAddress *from; | |
| /* This is not our local source, but lets check if two remote | |
| * source collide */ | |
| if (rtp) { | |
| from = source->rtp_from; | |
| } else { | |
| from = source->rtcp_from; | |
| } | |
| if (from) { | |
| if (__g_socket_address_equal (from, pinfo->address)) { | |
| /* Address is the same */ | |
| return FALSE; | |
| } else { | |
| GST_LOG ("we have a third-party collision or loop ssrc:%x", ssrc); | |
| if (sess->favor_new) { | |
| if (rtp_source_find_conflicting_address (source, | |
| pinfo->address, pinfo->current_time)) { | |
| gchar *buf1; | |
| buf1 = __g_socket_address_to_string (pinfo->address); | |
| GST_LOG ("Known conflict on %x for %s, dropping packet", ssrc, | |
| buf1); | |
| g_free (buf1); | |
| return TRUE; | |
| } else { | |
| gchar *buf1, *buf2; | |
| /* Current address is not a known conflict, lets assume this is | |
| * a new source. Save old address in possible conflict list | |
| */ | |
| rtp_source_add_conflicting_address (source, from, | |
| pinfo->current_time); | |
| buf1 = __g_socket_address_to_string (from); | |
| buf2 = __g_socket_address_to_string (pinfo->address); | |
| GST_DEBUG ("New conflict for ssrc %x, replacing %s with %s," | |
| " saving old as known conflict", ssrc, buf1, buf2); | |
| if (rtp) | |
| rtp_source_set_rtp_from (source, pinfo->address); | |
| else | |
| rtp_source_set_rtcp_from (source, pinfo->address); | |
| g_free (buf1); | |
| g_free (buf2); | |
| return FALSE; | |
| } | |
| } else { | |
| /* Don't need to save old addresses, we ignore new sources */ | |
| return TRUE; | |
| } | |
| } | |
| } else { | |
| /* We don't already have a from address for RTP, just set it */ | |
| if (rtp) | |
| rtp_source_set_rtp_from (source, pinfo->address); | |
| else | |
| rtp_source_set_rtcp_from (source, pinfo->address); | |
| return FALSE; | |
| } | |
| /* FIXME: Log 3rd party collision somehow | |
| * Maybe should be done in upper layer, only the SDES can tell us | |
| * if its a collision or a loop | |
| */ | |
| } else { | |
| /* This is sending with our ssrc, is it an address we already know */ | |
| if (rtp_session_find_conflicting_address (sess, pinfo->address, | |
| pinfo->current_time)) { | |
| /* Its a known conflict, its probably a loop, not a collision | |
| * lets just drop the incoming packet | |
| */ | |
| GST_DEBUG ("Our packets are being looped back to us, dropping"); | |
| } else { | |
| GST_DEBUG ("Collision for SSRC %x from new incoming packet," | |
| " change our sender ssrc", ssrc); | |
| rtp_session_have_conflict (sess, source, pinfo->address, | |
| pinfo->current_time); | |
| } | |
| } | |
| return TRUE; | |
| } | |
| typedef struct | |
| { | |
| gboolean is_doing_ptp; | |
| GSocketAddress *new_addr; | |
| } CompareAddrData; | |
| /* check if the two given ip addr are the same (do not care about the port) */ | |
| static gboolean | |
| ip_addr_equal (GSocketAddress * a, GSocketAddress * b) | |
| { | |
| return | |
| g_inet_address_equal (g_inet_socket_address_get_address | |
| (G_INET_SOCKET_ADDRESS (a)), | |
| g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (b))); | |
| } | |
| static void | |
| compare_rtp_source_addr (const gchar * key, RTPSource * source, | |
| CompareAddrData * data) | |
| { | |
| /* only compare ip addr of remote sources which are also not closing */ | |
| if (!source->internal && !source->closing && source->rtp_from) { | |
| /* look for the first rtp source */ | |
| if (!data->new_addr) | |
| data->new_addr = source->rtp_from; | |
| /* compare current ip addr with the first one */ | |
| else | |
| data->is_doing_ptp &= ip_addr_equal (data->new_addr, source->rtp_from); | |
| } | |
| } | |
| static void | |
| compare_rtcp_source_addr (const gchar * key, RTPSource * source, | |
| CompareAddrData * data) | |
| { | |
| /* only compare ip addr of remote sources which are also not closing */ | |
| if (!source->internal && !source->closing && source->rtcp_from) { | |
| /* look for the first rtcp source */ | |
| if (!data->new_addr) | |
| data->new_addr = source->rtcp_from; | |
| else | |
| /* compare current ip addr with the first one */ | |
| data->is_doing_ptp &= ip_addr_equal (data->new_addr, source->rtcp_from); | |
| } | |
| } | |
| /* loop over our non-internal source to know if the session | |
| * is doing point-to-point */ | |
| static void | |
| session_update_ptp (RTPSession * sess) | |
| { | |
| /* to know if the session is doing point to point, the ip addr | |
| * of each non-internal (=remotes) source have to be compared | |
| * to each other. | |
| */ | |
| gboolean is_doing_rtp_ptp; | |
| gboolean is_doing_rtcp_ptp; | |
| CompareAddrData data; | |
| /* compare the first remote source's ip addr that receive rtp packets | |
| * with other remote rtp source. | |
| * it's enough because the session just needs to know if they are all | |
| * equals or not | |
| */ | |
| data.is_doing_ptp = TRUE; | |
| data.new_addr = NULL; | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) compare_rtp_source_addr, (gpointer) & data); | |
| is_doing_rtp_ptp = data.is_doing_ptp; | |
| /* same but about rtcp */ | |
| data.is_doing_ptp = TRUE; | |
| data.new_addr = NULL; | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) compare_rtcp_source_addr, (gpointer) & data); | |
| is_doing_rtcp_ptp = data.is_doing_ptp; | |
| /* the session is doing point-to-point if all rtp remote have the same | |
| * ip addr and if all rtcp remote sources have the same ip addr */ | |
| sess->is_doing_ptp = is_doing_rtp_ptp && is_doing_rtcp_ptp; | |
| GST_DEBUG ("doing point-to-point: %d", sess->is_doing_ptp); | |
| } | |
| static void | |
| add_source (RTPSession * sess, RTPSource * src) | |
| { | |
| g_hash_table_insert (sess->ssrcs[sess->mask_idx], | |
| GINT_TO_POINTER (src->ssrc), src); | |
| /* report the new source ASAP */ | |
| src->generation = sess->generation; | |
| /* we have one more source now */ | |
| sess->total_sources++; | |
| if (RTP_SOURCE_IS_ACTIVE (src)) | |
| sess->stats.active_sources++; | |
| if (src->internal) { | |
| sess->stats.internal_sources++; | |
| if (!sess->internal_ssrc_from_caps_or_property | |
| && sess->suggested_ssrc != src->ssrc) { | |
| sess->suggested_ssrc = src->ssrc; | |
| sess->internal_ssrc_set = TRUE; | |
| } | |
| } | |
| /* update point-to-point status */ | |
| if (!src->internal) | |
| session_update_ptp (sess); | |
| } | |
| static RTPSource * | |
| find_source (RTPSession * sess, guint32 ssrc) | |
| { | |
| return g_hash_table_lookup (sess->ssrcs[sess->mask_idx], | |
| GINT_TO_POINTER (ssrc)); | |
| } | |
| /* must be called with the session lock, the returned source needs to be | |
| * unreffed after usage. */ | |
| static RTPSource * | |
| obtain_source (RTPSession * sess, guint32 ssrc, gboolean * created, | |
| RTPPacketInfo * pinfo, gboolean rtp) | |
| { | |
| RTPSource *source; | |
| source = find_source (sess, ssrc); | |
| if (source == NULL) { | |
| /* make new Source in probation and insert */ | |
| source = rtp_source_new (ssrc); | |
| GST_DEBUG ("creating new source %08x %p", ssrc, source); | |
| /* for RTP packets we need to set the source in probation. Receiving RTCP | |
| * packets of an SSRC, on the other hand, is a strong indication that we | |
| * are dealing with a valid source. */ | |
| g_object_set (source, "probation", rtp ? sess->probation : 0, | |
| "max-dropout-time", sess->max_dropout_time, "max-misorder-time", | |
| sess->max_misorder_time, NULL); | |
| /* store from address, if any */ | |
| if (pinfo->address) { | |
| if (rtp) | |
| rtp_source_set_rtp_from (source, pinfo->address); | |
| else | |
| rtp_source_set_rtcp_from (source, pinfo->address); | |
| } | |
| /* configure a callback on the source */ | |
| rtp_source_set_callbacks (source, &callbacks, sess); | |
| add_source (sess, source); | |
| *created = TRUE; | |
| } else { | |
| *created = FALSE; | |
| /* check for collision, this updates the address when not previously set */ | |
| if (check_collision (sess, source, pinfo, rtp)) { | |
| return NULL; | |
| } | |
| /* Receiving RTCP packets of an SSRC is a strong indication that we | |
| * are dealing with a valid source. */ | |
| if (!rtp) | |
| g_object_set (source, "probation", 0, NULL); | |
| } | |
| /* update last activity */ | |
| source->last_activity = pinfo->current_time; | |
| if (rtp) | |
| source->last_rtp_activity = pinfo->current_time; | |
| g_object_ref (source); | |
| return source; | |
| } | |
| /* must be called with the session lock, the returned source needs to be | |
| * unreffed after usage. */ | |
| static RTPSource * | |
| obtain_internal_source (RTPSession * sess, guint32 ssrc, gboolean * created, | |
| GstClockTime current_time) | |
| { | |
| RTPSource *source; | |
| source = find_source (sess, ssrc); | |
| if (source == NULL) { | |
| /* make new internal Source and insert */ | |
| source = rtp_source_new (ssrc); | |
| GST_DEBUG ("creating new internal source %08x %p", ssrc, source); | |
| source->validated = TRUE; | |
| source->internal = TRUE; | |
| source->probation = 0; | |
| source->curr_probation = 0; | |
| rtp_source_set_sdes_struct (source, gst_structure_copy (sess->sdes)); | |
| rtp_source_set_callbacks (source, &callbacks, sess); | |
| add_source (sess, source); | |
| *created = TRUE; | |
| } else { | |
| *created = FALSE; | |
| } | |
| /* update last activity */ | |
| if (current_time != GST_CLOCK_TIME_NONE) { | |
| source->last_activity = current_time; | |
| source->last_rtp_activity = current_time; | |
| } | |
| g_object_ref (source); | |
| return source; | |
| } | |
| /** | |
| * rtp_session_suggest_ssrc: | |
| * @sess: a #RTPSession | |
| * @is_random: if the suggested ssrc is random | |
| * | |
| * Suggest an unused SSRC in @sess. | |
| * | |
| * Returns: a free unused SSRC | |
| */ | |
| guint32 | |
| rtp_session_suggest_ssrc (RTPSession * sess, gboolean * is_random) | |
| { | |
| guint32 result; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), 0); | |
| RTP_SESSION_LOCK (sess); | |
| result = sess->suggested_ssrc; | |
| if (is_random) | |
| *is_random = !sess->internal_ssrc_set; | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_add_source: | |
| * @sess: a #RTPSession | |
| * @src: #RTPSource to add | |
| * | |
| * Add @src to @session. | |
| * | |
| * Returns: %TRUE on success, %FALSE if a source with the same SSRC already | |
| * existed in the session. | |
| */ | |
| gboolean | |
| rtp_session_add_source (RTPSession * sess, RTPSource * src) | |
| { | |
| gboolean result = FALSE; | |
| RTPSource *find; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), FALSE); | |
| g_return_val_if_fail (src != NULL, FALSE); | |
| RTP_SESSION_LOCK (sess); | |
| find = find_source (sess, src->ssrc); | |
| if (find == NULL) { | |
| add_source (sess, src); | |
| result = TRUE; | |
| } | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_get_num_sources: | |
| * @sess: an #RTPSession | |
| * | |
| * Get the number of sources in @sess. | |
| * | |
| * Returns: The number of sources in @sess. | |
| */ | |
| guint | |
| rtp_session_get_num_sources (RTPSession * sess) | |
| { | |
| guint result; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), FALSE); | |
| RTP_SESSION_LOCK (sess); | |
| result = sess->total_sources; | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_get_num_active_sources: | |
| * @sess: an #RTPSession | |
| * | |
| * Get the number of active sources in @sess. A source is considered active when | |
| * it has been validated and has not yet received a BYE RTCP message. | |
| * | |
| * Returns: The number of active sources in @sess. | |
| */ | |
| guint | |
| rtp_session_get_num_active_sources (RTPSession * sess) | |
| { | |
| guint result; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), 0); | |
| RTP_SESSION_LOCK (sess); | |
| result = sess->stats.active_sources; | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_get_source_by_ssrc: | |
| * @sess: an #RTPSession | |
| * @ssrc: an SSRC | |
| * | |
| * Find the source with @ssrc in @sess. | |
| * | |
| * Returns: a #RTPSource with SSRC @ssrc or NULL if the source was not found. | |
| * g_object_unref() after usage. | |
| */ | |
| RTPSource * | |
| rtp_session_get_source_by_ssrc (RTPSession * sess, guint32 ssrc) | |
| { | |
| RTPSource *result; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), NULL); | |
| RTP_SESSION_LOCK (sess); | |
| result = find_source (sess, ssrc); | |
| if (result != NULL) | |
| g_object_ref (result); | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /* should be called with the SESSION lock */ | |
| static guint32 | |
| rtp_session_create_new_ssrc (RTPSession * sess) | |
| { | |
| guint32 ssrc; | |
| while (TRUE) { | |
| ssrc = g_random_int (); | |
| /* see if it exists in the session, we're done if it doesn't */ | |
| if (find_source (sess, ssrc) == NULL) | |
| break; | |
| } | |
| return ssrc; | |
| } | |
| static gboolean | |
| update_packet (GstBuffer ** buffer, guint idx, RTPPacketInfo * pinfo) | |
| { | |
| GstNetAddressMeta *meta; | |
| /* get packet size including header overhead */ | |
| pinfo->bytes += gst_buffer_get_size (*buffer) + pinfo->header_len; | |
| pinfo->packets++; | |
| if (pinfo->rtp) { | |
| GstRTPBuffer rtp = { NULL }; | |
| if (!gst_rtp_buffer_map (*buffer, GST_MAP_READ, &rtp)) | |
| goto invalid_packet; | |
| pinfo->payload_len += gst_rtp_buffer_get_payload_len (&rtp); | |
| if (idx == 0) { | |
| gint i; | |
| /* only keep info for first buffer */ | |
| pinfo->ssrc = gst_rtp_buffer_get_ssrc (&rtp); | |
| pinfo->seqnum = gst_rtp_buffer_get_seq (&rtp); | |
| pinfo->pt = gst_rtp_buffer_get_payload_type (&rtp); | |
| pinfo->rtptime = gst_rtp_buffer_get_timestamp (&rtp); | |
| pinfo->marker = gst_rtp_buffer_get_marker (&rtp); | |
| /* copy available csrc */ | |
| pinfo->csrc_count = gst_rtp_buffer_get_csrc_count (&rtp); | |
| for (i = 0; i < pinfo->csrc_count; i++) | |
| pinfo->csrcs[i] = gst_rtp_buffer_get_csrc (&rtp, i); | |
| /* RTP header extensions */ | |
| pinfo->header_ext = gst_rtp_buffer_get_extension_bytes (&rtp, | |
| &pinfo->header_ext_bit_pattern); | |
| } | |
| if (pinfo->ntp64_ext_id != 0 && pinfo->send && !pinfo->have_ntp64_ext) { | |
| guint8 *data; | |
| guint size; | |
| /* Remember here that there is a 64-bit NTP header extension on this buffer | |
| * or any of the other buffers in the buffer list. | |
| * Later we update this after making the buffer(list) writable. | |
| */ | |
| if ((gst_rtp_buffer_get_extension_onebyte_header (&rtp, | |
| pinfo->ntp64_ext_id, 0, (gpointer *) & data, &size) | |
| && size == 8) | |
| || (gst_rtp_buffer_get_extension_twobytes_header (&rtp, NULL, | |
| pinfo->ntp64_ext_id, 0, (gpointer *) & data, &size) | |
| && size == 8)) { | |
| pinfo->have_ntp64_ext = TRUE; | |
| } | |
| } | |
| gst_rtp_buffer_unmap (&rtp); | |
| } | |
| if (idx == 0) { | |
| /* for netbuffer we can store the IP address to check for collisions */ | |
| meta = gst_buffer_get_net_address_meta (*buffer); | |
| if (pinfo->address) | |
| g_object_unref (pinfo->address); | |
| if (meta) { | |
| pinfo->address = G_SOCKET_ADDRESS (g_object_ref (meta->addr)); | |
| } else { | |
| pinfo->address = NULL; | |
| } | |
| } | |
| return TRUE; | |
| /* ERRORS */ | |
| invalid_packet: | |
| { | |
| GST_DEBUG ("invalid RTP packet received"); | |
| return FALSE; | |
| } | |
| } | |
| /* update the RTPPacketInfo structure with the current time and other bits | |
| * about the current buffer we are handling. | |
| * This function is typically called when a validated packet is received. | |
| * This function should be called with the RTP_SESSION_LOCK | |
| */ | |
| static gboolean | |
| update_packet_info (RTPSession * sess, RTPPacketInfo * pinfo, | |
| gboolean send, gboolean rtp, gboolean is_list, gpointer data, | |
| GstClockTime current_time, GstClockTime running_time, guint64 ntpnstime) | |
| { | |
| gboolean res; | |
| pinfo->send = send; | |
| pinfo->rtp = rtp; | |
| pinfo->is_list = is_list; | |
| pinfo->data = data; | |
| pinfo->current_time = current_time; | |
| pinfo->running_time = running_time; | |
| pinfo->ntpnstime = ntpnstime; | |
| pinfo->header_len = sess->header_len; | |
| pinfo->bytes = 0; | |
| pinfo->payload_len = 0; | |
| pinfo->packets = 0; | |
| pinfo->marker = FALSE; | |
| pinfo->ntp64_ext_id = send ? sess->send_ntp64_ext_id : 0; | |
| pinfo->have_ntp64_ext = FALSE; | |
| if (is_list) { | |
| GstBufferList *list = GST_BUFFER_LIST_CAST (data); | |
| res = | |
| gst_buffer_list_foreach (list, (GstBufferListFunc) update_packet, | |
| pinfo); | |
| pinfo->arrival_time = GST_CLOCK_TIME_NONE; | |
| } else { | |
| GstBuffer *buffer = GST_BUFFER_CAST (data); | |
| res = update_packet (&buffer, 0, pinfo); | |
| pinfo->arrival_time = GST_BUFFER_DTS (buffer); | |
| } | |
| return res; | |
| } | |
| static void | |
| clean_packet_info (RTPPacketInfo * pinfo) | |
| { | |
| if (pinfo->address) | |
| g_object_unref (pinfo->address); | |
| if (pinfo->data) { | |
| gst_mini_object_unref (pinfo->data); | |
| pinfo->data = NULL; | |
| } | |
| if (pinfo->header_ext) | |
| g_bytes_unref (pinfo->header_ext); | |
| } | |
| static gboolean | |
| source_update_active (RTPSession * sess, RTPSource * source, | |
| gboolean prevactive) | |
| { | |
| gboolean active = RTP_SOURCE_IS_ACTIVE (source); | |
| guint32 ssrc = source->ssrc; | |
| if (prevactive == active) | |
| return FALSE; | |
| if (active) { | |
| sess->stats.active_sources++; | |
| GST_DEBUG ("source: %08x became active, %d active sources", ssrc, | |
| sess->stats.active_sources); | |
| } else { | |
| sess->stats.active_sources--; | |
| GST_DEBUG ("source: %08x became inactive, %d active sources", ssrc, | |
| sess->stats.active_sources); | |
| } | |
| return TRUE; | |
| } | |
| static void | |
| process_twcc_packet (RTPSession * sess, RTPPacketInfo * pinfo) | |
| { | |
| if (rtp_twcc_manager_recv_packet (sess->twcc, pinfo)) { | |
| RTP_SESSION_UNLOCK (sess); | |
| /* TODO: find a better rational for this number, and possibly tune it based | |
| on factors like framerate / bandwidth etc */ | |
| if (!rtp_session_send_rtcp (sess, 100 * GST_MSECOND)) { | |
| GST_INFO ("Could not schedule TWCC straight away"); | |
| } | |
| RTP_SESSION_LOCK (sess); | |
| } | |
| } | |
| static gboolean | |
| source_update_sender (RTPSession * sess, RTPSource * source, | |
| gboolean prevsender) | |
| { | |
| gboolean sender = RTP_SOURCE_IS_SENDER (source); | |
| guint32 ssrc = source->ssrc; | |
| if (prevsender == sender) | |
| return FALSE; | |
| if (sender) { | |
| sess->stats.sender_sources++; | |
| if (source->internal) | |
| sess->stats.internal_sender_sources++; | |
| GST_DEBUG ("source: %08x became sender, %d sender sources", ssrc, | |
| sess->stats.sender_sources); | |
| } else { | |
| sess->stats.sender_sources--; | |
| if (source->internal) | |
| sess->stats.internal_sender_sources--; | |
| GST_DEBUG ("source: %08x became non sender, %d sender sources", ssrc, | |
| sess->stats.sender_sources); | |
| } | |
| return TRUE; | |
| } | |
| /** | |
| * rtp_session_process_rtp: | |
| * @sess: and #RTPSession | |
| * @buffer: an RTP buffer | |
| * @current_time: the current system time | |
| * @running_time: the running_time of @buffer | |
| * | |
| * Process an RTP buffer in the session manager. This function takes ownership | |
| * of @buffer. | |
| * | |
| * Returns: a #GstFlowReturn. | |
| */ | |
| GstFlowReturn | |
| rtp_session_process_rtp (RTPSession * sess, GstBuffer * buffer, | |
| GstClockTime current_time, GstClockTime running_time, guint64 ntpnstime) | |
| { | |
| GstFlowReturn result; | |
| guint32 ssrc; | |
| RTPSource *source; | |
| gboolean created; | |
| gboolean prevsender, prevactive; | |
| RTPPacketInfo pinfo = { 0, }; | |
| guint64 oldrate; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), GST_FLOW_ERROR); | |
| g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR); | |
| RTP_SESSION_LOCK (sess); | |
| /* update pinfo stats */ | |
| if (!update_packet_info (sess, &pinfo, FALSE, TRUE, FALSE, buffer, | |
| current_time, running_time, ntpnstime)) { | |
| GST_DEBUG ("invalid RTP packet received"); | |
| RTP_SESSION_UNLOCK (sess); | |
| return rtp_session_process_rtcp (sess, buffer, current_time, running_time, | |
| ntpnstime); | |
| } | |
| ssrc = pinfo.ssrc; | |
| source = obtain_source (sess, ssrc, &created, &pinfo, TRUE); | |
| if (!source) | |
| goto collision; | |
| prevsender = RTP_SOURCE_IS_SENDER (source); | |
| prevactive = RTP_SOURCE_IS_ACTIVE (source); | |
| oldrate = source->bitrate; | |
| if (created) | |
| on_new_ssrc (sess, source); | |
| /* let source process the packet */ | |
| result = rtp_source_process_rtp (source, &pinfo); | |
| process_twcc_packet (sess, &pinfo); | |
| /* source became active */ | |
| if (source_update_active (sess, source, prevactive)) | |
| on_ssrc_validated (sess, source); | |
| source_update_sender (sess, source, prevsender); | |
| if (oldrate != source->bitrate) | |
| sess->recalc_bandwidth = TRUE; | |
| if (source->validated) { | |
| gboolean created; | |
| gint i; | |
| /* for validated sources, we add the CSRCs as well */ | |
| for (i = 0; i < pinfo.csrc_count; i++) { | |
| guint32 csrc; | |
| RTPSource *csrc_src; | |
| csrc = pinfo.csrcs[i]; | |
| /* get source */ | |
| csrc_src = obtain_source (sess, csrc, &created, &pinfo, TRUE); | |
| if (!csrc_src) | |
| continue; | |
| if (created) { | |
| GST_DEBUG ("created new CSRC: %08x", csrc); | |
| rtp_source_set_as_csrc (csrc_src); | |
| source_update_active (sess, csrc_src, FALSE); | |
| on_new_ssrc (sess, csrc_src); | |
| } | |
| g_object_unref (csrc_src); | |
| } | |
| } | |
| g_object_unref (source); | |
| RTP_SESSION_UNLOCK (sess); | |
| clean_packet_info (&pinfo); | |
| return result; | |
| /* ERRORS */ | |
| collision: | |
| { | |
| RTP_SESSION_UNLOCK (sess); | |
| clean_packet_info (&pinfo); | |
| GST_DEBUG ("ignoring packet because its collisioning"); | |
| return GST_FLOW_OK; | |
| } | |
| } | |
| static void | |
| rtp_session_process_rb (RTPSession * sess, RTPSource * source, | |
| GstRTCPPacket * packet, RTPPacketInfo * pinfo) | |
| { | |
| guint count, i; | |
| count = gst_rtcp_packet_get_rb_count (packet); | |
| for (i = 0; i < count; i++) { | |
| guint32 ssrc, exthighestseq, jitter, lsr, dlsr; | |
| guint8 fractionlost; | |
| gint32 packetslost; | |
| RTPSource *src; | |
| gst_rtcp_packet_get_rb (packet, i, &ssrc, &fractionlost, | |
| &packetslost, &exthighestseq, &jitter, &lsr, &dlsr); | |
| GST_DEBUG ("RB %d: SSRC %08x, jitter %" G_GUINT32_FORMAT, i, ssrc, jitter); | |
| /* find our own source */ | |
| src = find_source (sess, ssrc); | |
| if (src == NULL) | |
| continue; | |
| if (src->internal && RTP_SOURCE_IS_ACTIVE (src)) { | |
| /* only deal with report blocks for our session, we update the stats of | |
| * the sender of the RTCP message. We could also compare our stats against | |
| * the other sender to see if we are better or worse. */ | |
| /* FIXME, need to keep track who the RB block is from */ | |
| rtp_source_process_rb (source, ssrc, pinfo->ntpnstime, fractionlost, | |
| packetslost, exthighestseq, jitter, lsr, dlsr); | |
| } | |
| } | |
| on_ssrc_active (sess, source); | |
| } | |
| /* A Sender report contains statistics about how the sender is doing. This | |
| * includes timing informataion such as the relation between RTP and NTP | |
| * timestamps and the number of packets/bytes it sent to us. | |
| * | |
| * In this report is also included a set of report blocks related to how this | |
| * sender is receiving data (in case we (or somebody else) is also sending stuff | |
| * to it). This info includes the packet loss, jitter and seqnum. It also | |
| * contains information to calculate the round trip time (LSR/DLSR). | |
| */ | |
| static void | |
| rtp_session_process_sr (RTPSession * sess, GstRTCPPacket * packet, | |
| RTPPacketInfo * pinfo, gboolean * do_sync) | |
| { | |
| guint32 senderssrc, rtptime, packet_count, octet_count; | |
| guint64 ntptime; | |
| RTPSource *source; | |
| gboolean created, prevsender; | |
| gst_rtcp_packet_sr_get_sender_info (packet, &senderssrc, &ntptime, &rtptime, | |
| &packet_count, &octet_count); | |
| GST_DEBUG ("got SR packet: SSRC %08x, time %" GST_TIME_FORMAT, | |
| senderssrc, GST_TIME_ARGS (pinfo->current_time)); | |
| source = obtain_source (sess, senderssrc, &created, pinfo, FALSE); | |
| if (!source) | |
| return; | |
| /* skip non-bye packets for sources that are marked BYE */ | |
| if (sess->scheduled_bye && RTP_SOURCE_IS_MARKED_BYE (source)) | |
| goto out; | |
| /* don't try to do lip-sync for sources that sent a BYE */ | |
| if (RTP_SOURCE_IS_MARKED_BYE (source)) | |
| *do_sync = FALSE; | |
| else | |
| *do_sync = TRUE; | |
| prevsender = RTP_SOURCE_IS_SENDER (source); | |
| /* first update the source */ | |
| rtp_source_process_sr (source, pinfo->current_time, ntptime, rtptime, | |
| packet_count, octet_count); | |
| source_update_sender (sess, source, prevsender); | |
| if (created) | |
| on_new_ssrc (sess, source); | |
| rtp_session_process_rb (sess, source, packet, pinfo); | |
| out: | |
| g_object_unref (source); | |
| } | |
| /* A receiver report contains statistics about how a receiver is doing. It | |
| * includes stuff like packet loss, jitter and the seqnum it received last. It | |
| * also contains info to calculate the round trip time. | |
| * | |
| * We are only interested in how the sender of this report is doing wrt to us. | |
| */ | |
| static void | |
| rtp_session_process_rr (RTPSession * sess, GstRTCPPacket * packet, | |
| RTPPacketInfo * pinfo) | |
| { | |
| guint32 senderssrc; | |
| RTPSource *source; | |
| gboolean created; | |
| senderssrc = gst_rtcp_packet_rr_get_ssrc (packet); | |
| GST_DEBUG ("got RR packet: SSRC %08x", senderssrc); | |
| source = obtain_source (sess, senderssrc, &created, pinfo, FALSE); | |
| if (!source) | |
| return; | |
| /* skip non-bye packets for sources that are marked BYE */ | |
| if (sess->scheduled_bye && RTP_SOURCE_IS_MARKED_BYE (source)) | |
| goto out; | |
| if (created) | |
| on_new_ssrc (sess, source); | |
| rtp_session_process_rb (sess, source, packet, pinfo); | |
| out: | |
| g_object_unref (source); | |
| } | |
| /* Get SDES items and store them in the SSRC */ | |
| static void | |
| rtp_session_process_sdes (RTPSession * sess, GstRTCPPacket * packet, | |
| RTPPacketInfo * pinfo) | |
| { | |
| guint items, i, j; | |
| gboolean more_items, more_entries; | |
| items = gst_rtcp_packet_sdes_get_item_count (packet); | |
| GST_DEBUG ("got SDES packet with %d items", items); | |
| more_items = gst_rtcp_packet_sdes_first_item (packet); | |
| i = 0; | |
| while (more_items) { | |
| guint32 ssrc; | |
| gboolean changed, created, prevactive; | |
| RTPSource *source; | |
| GstStructure *sdes; | |
| ssrc = gst_rtcp_packet_sdes_get_ssrc (packet); | |
| GST_DEBUG ("item %d, SSRC %08x", i, ssrc); | |
| changed = FALSE; | |
| /* find src, no probation when dealing with RTCP */ | |
| source = obtain_source (sess, ssrc, &created, pinfo, FALSE); | |
| if (!source) | |
| return; | |
| /* skip non-bye packets for sources that are marked BYE */ | |
| if (sess->scheduled_bye && RTP_SOURCE_IS_MARKED_BYE (source)) | |
| goto next; | |
| sdes = gst_structure_new_empty ("application/x-rtp-source-sdes"); | |
| more_entries = gst_rtcp_packet_sdes_first_entry (packet); | |
| j = 0; | |
| while (more_entries) { | |
| GstRTCPSDESType type; | |
| guint8 len; | |
| guint8 *data; | |
| gchar *name; | |
| gchar *value; | |
| gst_rtcp_packet_sdes_get_entry (packet, &type, &len, &data); | |
| GST_DEBUG ("entry %d, type %d, len %d, data %.*s", j, type, len, len, | |
| data); | |
| if (type == GST_RTCP_SDES_PRIV) { | |
| name = g_strndup ((const gchar *) &data[1], data[0]); | |
| len -= data[0] + 1; | |
| data += data[0] + 1; | |
| } else { | |
| name = g_strdup (gst_rtcp_sdes_type_to_name (type)); | |
| } | |
| value = g_strndup ((const gchar *) data, len); | |
| if (g_utf8_validate (value, -1, NULL)) { | |
| gst_structure_set (sdes, name, G_TYPE_STRING, value, NULL); | |
| } else { | |
| GST_WARNING ("ignore SDES field %s with non-utf8 data %s", name, value); | |
| } | |
| g_free (name); | |
| g_free (value); | |
| more_entries = gst_rtcp_packet_sdes_next_entry (packet); | |
| j++; | |
| } | |
| /* takes ownership of sdes */ | |
| changed = rtp_source_set_sdes_struct (source, sdes); | |
| prevactive = RTP_SOURCE_IS_ACTIVE (source); | |
| source->validated = TRUE; | |
| if (created) | |
| on_new_ssrc (sess, source); | |
| /* source became active */ | |
| if (source_update_active (sess, source, prevactive)) | |
| on_ssrc_validated (sess, source); | |
| if (changed) | |
| on_ssrc_sdes (sess, source); | |
| next: | |
| g_object_unref (source); | |
| more_items = gst_rtcp_packet_sdes_next_item (packet); | |
| i++; | |
| } | |
| } | |
| /* BYE is sent when a client leaves the session | |
| */ | |
| static void | |
| rtp_session_process_bye (RTPSession * sess, GstRTCPPacket * packet, | |
| RTPPacketInfo * pinfo) | |
| { | |
| guint count, i; | |
| gchar *reason; | |
| gboolean reconsider = FALSE; | |
| reason = gst_rtcp_packet_bye_get_reason (packet); | |
| GST_DEBUG ("got BYE packet (reason: %s)", GST_STR_NULL (reason)); | |
| count = gst_rtcp_packet_bye_get_ssrc_count (packet); | |
| for (i = 0; i < count; i++) { | |
| guint32 ssrc; | |
| RTPSource *source; | |
| gboolean prevactive, prevsender; | |
| guint pmembers, members; | |
| ssrc = gst_rtcp_packet_bye_get_nth_ssrc (packet, i); | |
| GST_DEBUG ("SSRC: %08x", ssrc); | |
| /* find src and mark bye, no probation when dealing with RTCP */ | |
| source = find_source (sess, ssrc); | |
| if (!source || source->internal) { | |
| GST_DEBUG ("Ignoring suspicious BYE packet (reason: %s)", | |
| !source ? "can't find source" : "has internal source SSRC"); | |
| break; | |
| } | |
| /* store time for when we need to time out this source */ | |
| source->bye_time = pinfo->current_time; | |
| prevactive = RTP_SOURCE_IS_ACTIVE (source); | |
| prevsender = RTP_SOURCE_IS_SENDER (source); | |
| /* mark the source BYE */ | |
| rtp_source_mark_bye (source, reason); | |
| pmembers = sess->stats.active_sources; | |
| source_update_active (sess, source, prevactive); | |
| source_update_sender (sess, source, prevsender); | |
| members = sess->stats.active_sources; | |
| if (!sess->scheduled_bye && members < pmembers) { | |
| /* some members went away since the previous timeout estimate. | |
| * Perform reverse reconsideration but only when we are not scheduling a | |
| * BYE ourselves. */ | |
| if (sess->next_rtcp_check_time != GST_CLOCK_TIME_NONE && | |
| pinfo->current_time < sess->next_rtcp_check_time) { | |
| GstClockTime time_remaining; | |
| /* Scale our next RTCP check time according to the change of numbers | |
| * of members. But only if a) this is the first RTCP, or b) this is not | |
| * a feedback session, or c) this is a feedback session but we schedule | |
| * for every RTCP interval (aka no t-rr-interval set). | |
| * | |
| * FIXME: a) and b) are not great as we will possibly go below Tmin | |
| * for non-feedback profiles and in case of a) below | |
| * Tmin/t-rr-interval in any case. | |
| */ | |
| if (sess->last_rtcp_send_time == GST_CLOCK_TIME_NONE || | |
| !(sess->rtp_profile == GST_RTP_PROFILE_AVPF | |
| || sess->rtp_profile == GST_RTP_PROFILE_SAVPF) || | |
| sess->next_rtcp_check_time - sess->last_rtcp_send_time == | |
| sess->last_rtcp_interval) { | |
| time_remaining = sess->next_rtcp_check_time - pinfo->current_time; | |
| sess->next_rtcp_check_time = | |
| gst_util_uint64_scale (time_remaining, members, pmembers); | |
| sess->next_rtcp_check_time += pinfo->current_time; | |
| } | |
| sess->last_rtcp_interval = | |
| gst_util_uint64_scale (sess->last_rtcp_interval, members, pmembers); | |
| GST_DEBUG ("reverse reconsideration %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| /* mark pending reconsider. We only want to signal the reconsideration | |
| * once after we handled all the source in the bye packet */ | |
| reconsider = TRUE; | |
| } | |
| } | |
| on_bye_ssrc (sess, source); | |
| } | |
| if (reconsider) { | |
| RTP_SESSION_UNLOCK (sess); | |
| /* notify app of reconsideration */ | |
| if (sess->callbacks.reconsider) | |
| sess->callbacks.reconsider (sess, sess->reconsider_user_data); | |
| RTP_SESSION_LOCK (sess); | |
| } | |
| g_free (reason); | |
| } | |
| static void | |
| rtp_session_process_app (RTPSession * sess, GstRTCPPacket * packet, | |
| RTPPacketInfo * pinfo) | |
| { | |
| GST_DEBUG ("received APP"); | |
| if (g_signal_has_handler_pending (sess, | |
| rtp_session_signals[SIGNAL_ON_APP_RTCP], 0, TRUE)) { | |
| GstBuffer *data_buffer = NULL; | |
| guint16 data_length; | |
| gchar name[5]; | |
| data_length = gst_rtcp_packet_app_get_data_length (packet) * 4; | |
| if (data_length > 0) { | |
| guint8 *data = gst_rtcp_packet_app_get_data (packet); | |
| data_buffer = gst_buffer_copy_region (packet->rtcp->buffer, | |
| GST_BUFFER_COPY_MEMORY, data - packet->rtcp->map.data, data_length); | |
| GST_BUFFER_PTS (data_buffer) = pinfo->running_time; | |
| } | |
| memcpy (name, gst_rtcp_packet_app_get_name (packet), 4); | |
| name[4] = '\0'; | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_APP_RTCP], 0, | |
| gst_rtcp_packet_app_get_subtype (packet), | |
| gst_rtcp_packet_app_get_ssrc (packet), name, data_buffer); | |
| RTP_SESSION_LOCK (sess); | |
| if (data_buffer) | |
| gst_buffer_unref (data_buffer); | |
| } | |
| } | |
| static gboolean | |
| rtp_session_request_local_key_unit (RTPSession * sess, RTPSource * src, | |
| const guint32 * ssrcs, guint num_ssrcs, gboolean fir, | |
| GstClockTime current_time) | |
| { | |
| guint32 round_trip = 0; | |
| gint i; | |
| g_return_val_if_fail (ssrcs != NULL && num_ssrcs > 0, FALSE); | |
| rtp_source_get_last_rb (src, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
| &round_trip); | |
| if (src->last_keyframe_request != GST_CLOCK_TIME_NONE && round_trip) { | |
| GstClockTime round_trip_in_ns = gst_util_uint64_scale (round_trip, | |
| GST_SECOND, 65536); | |
| /* Sanity check to avoid always ignoring PLI/FIR if we receive RTCP | |
| * packets with erroneous values resulting in crazy high RTT. */ | |
| if (round_trip_in_ns > 5 * GST_SECOND) | |
| round_trip_in_ns = GST_SECOND / 2; | |
| if (current_time - src->last_keyframe_request < 2 * round_trip_in_ns) { | |
| GST_DEBUG ("Ignoring %s request from %X because one was send without one " | |
| "RTT (%" GST_TIME_FORMAT " < %" GST_TIME_FORMAT ")", | |
| fir ? "FIR" : "PLI", rtp_source_get_ssrc (src), | |
| GST_TIME_ARGS (current_time - src->last_keyframe_request), | |
| GST_TIME_ARGS (round_trip_in_ns)); | |
| return FALSE; | |
| } | |
| } | |
| src->last_keyframe_request = current_time; | |
| for (i = 0; i < num_ssrcs; ++i) { | |
| GST_LOG ("received %s request from %X about %X %p(%p)", | |
| fir ? "FIR" : "PLI", | |
| rtp_source_get_ssrc (src), ssrcs[i], sess->callbacks.process_rtp, | |
| sess->callbacks.request_key_unit); | |
| RTP_SESSION_UNLOCK (sess); | |
| sess->callbacks.request_key_unit (sess, ssrcs[i], fir, | |
| sess->request_key_unit_user_data); | |
| RTP_SESSION_LOCK (sess); | |
| } | |
| return TRUE; | |
| } | |
| static void | |
| rtp_session_process_pli (RTPSession * sess, guint32 sender_ssrc, | |
| guint32 media_ssrc, GstClockTime current_time) | |
| { | |
| RTPSource *src; | |
| if (!sess->callbacks.request_key_unit) | |
| return; | |
| src = find_source (sess, sender_ssrc); | |
| if (src == NULL) { | |
| /* try to find a src with media_ssrc instead */ | |
| src = find_source (sess, media_ssrc); | |
| if (src == NULL) | |
| return; | |
| } | |
| rtp_session_request_local_key_unit (sess, src, &media_ssrc, 1, FALSE, | |
| current_time); | |
| } | |
| static void | |
| rtp_session_process_fir (RTPSession * sess, guint32 sender_ssrc, | |
| guint8 * fci_data, guint fci_length, GstClockTime current_time) | |
| { | |
| RTPSource *src; | |
| guint32 ssrc; | |
| guint position = 0; | |
| guint32 ssrcs[32]; | |
| guint num_ssrcs = 0; | |
| if (!sess->callbacks.request_key_unit) | |
| return; | |
| if (fci_length < 8) | |
| return; | |
| src = find_source (sess, sender_ssrc); | |
| /* Hack because Google fails to set the sender_ssrc correctly */ | |
| if (!src && sender_ssrc == 1) { | |
| GHashTableIter iter; | |
| /* we can't find the source if there are multiple */ | |
| if (sess->stats.sender_sources > sess->stats.internal_sender_sources + 1) | |
| return; | |
| g_hash_table_iter_init (&iter, sess->ssrcs[sess->mask_idx]); | |
| while (g_hash_table_iter_next (&iter, NULL, (gpointer *) & src)) { | |
| if (!src->internal && rtp_source_is_sender (src)) | |
| break; | |
| src = NULL; | |
| } | |
| } | |
| if (!src) | |
| return; | |
| for (position = 0; position < fci_length; position += 8) { | |
| guint8 *data = fci_data + position; | |
| RTPSource *own; | |
| ssrc = GST_READ_UINT32_BE (data); | |
| own = find_source (sess, ssrc); | |
| if (own == NULL) | |
| continue; | |
| if (own->internal && num_ssrcs < 32) { | |
| ssrcs[num_ssrcs++] = ssrc; | |
| } | |
| } | |
| if (num_ssrcs == 0) | |
| return; | |
| rtp_session_request_local_key_unit (sess, src, ssrcs, num_ssrcs, TRUE, | |
| current_time); | |
| } | |
| static void | |
| rtp_session_process_nack (RTPSession * sess, guint32 sender_ssrc, | |
| guint32 media_ssrc, guint8 * fci_data, guint fci_length, | |
| GstClockTime current_time) | |
| { | |
| sess->stats.nacks_received++; | |
| if (!sess->callbacks.notify_nack) | |
| return; | |
| while (fci_length > 0) { | |
| guint16 seqnum, blp; | |
| seqnum = GST_READ_UINT16_BE (fci_data); | |
| blp = GST_READ_UINT16_BE (fci_data + 2); | |
| GST_DEBUG ("NACK #%u, blp %04x, SSRC 0x%08x", seqnum, blp, media_ssrc); | |
| RTP_SESSION_UNLOCK (sess); | |
| sess->callbacks.notify_nack (sess, seqnum, blp, media_ssrc, | |
| sess->notify_nack_user_data); | |
| RTP_SESSION_LOCK (sess); | |
| fci_data += 4; | |
| fci_length -= 4; | |
| } | |
| } | |
| static void | |
| rtp_session_process_sr_req (RTPSession * sess, guint32 sender_ssrc, | |
| guint32 media_ssrc) | |
| { | |
| RTPSource *src; | |
| /* Request a new SR in feedback profiles ASAP */ | |
| if (sess->rtp_profile != GST_RTP_PROFILE_AVPF | |
| && sess->rtp_profile != GST_RTP_PROFILE_SAVPF) | |
| return; | |
| src = find_source (sess, sender_ssrc); | |
| /* Our own RTCP packet */ | |
| if (src && src->internal) | |
| return; | |
| src = find_source (sess, media_ssrc); | |
| /* Not an SSRC we're producing */ | |
| if (!src || !src->internal) | |
| return; | |
| GST_DEBUG_OBJECT (sess, "Handling RTCP-SR-REQ"); | |
| /* FIXME: 5s max_delay hard-coded here as we have to give some | |
| * high enough value */ | |
| sess->sr_req_pending = TRUE; | |
| rtp_session_send_rtcp (sess, 5 * GST_SECOND); | |
| } | |
| static void | |
| rtp_session_process_twcc (RTPSession * sess, guint32 sender_ssrc, | |
| guint32 media_ssrc, guint8 * fci_data, guint fci_length) | |
| { | |
| GArray *twcc_packets; | |
| GstStructure *twcc_packets_s; | |
| GstStructure *twcc_stats_s; | |
| twcc_packets = rtp_twcc_manager_parse_fci (sess->twcc, | |
| fci_data, fci_length * sizeof (guint32)); | |
| if (twcc_packets == NULL) | |
| return; | |
| twcc_packets_s = rtp_twcc_stats_get_packets_structure (twcc_packets); | |
| twcc_stats_s = | |
| rtp_twcc_stats_process_packets (sess->twcc_stats, twcc_packets); | |
| GST_DEBUG_OBJECT (sess, "Parsed TWCC: %" GST_PTR_FORMAT, twcc_packets_s); | |
| GST_INFO_OBJECT (sess, "Current TWCC stats %" GST_PTR_FORMAT, twcc_stats_s); | |
| g_array_unref (twcc_packets); | |
| RTP_SESSION_UNLOCK (sess); | |
| if (sess->callbacks.notify_twcc) | |
| sess->callbacks.notify_twcc (sess, g_steal_pointer (&twcc_packets_s), | |
| g_steal_pointer (&twcc_stats_s), sess->notify_twcc_user_data); | |
| else { | |
| gst_structure_free (twcc_packets_s); | |
| gst_structure_free (twcc_stats_s); | |
| } | |
| RTP_SESSION_LOCK (sess); | |
| } | |
| static void | |
| rtp_session_process_feedback (RTPSession * sess, GstRTCPPacket * packet, | |
| RTPPacketInfo * pinfo, GstClockTime current_time) | |
| { | |
| GstRTCPType type; | |
| GstRTCPFBType fbtype; | |
| guint32 sender_ssrc, media_ssrc; | |
| guint8 *fci_data; | |
| guint fci_length; | |
| RTPSource *src; | |
| /* The feedback packet must include both sender SSRC and media SSRC */ | |
| if (packet->length < 2) | |
| return; | |
| type = gst_rtcp_packet_get_type (packet); | |
| fbtype = gst_rtcp_packet_fb_get_type (packet); | |
| sender_ssrc = gst_rtcp_packet_fb_get_sender_ssrc (packet); | |
| media_ssrc = gst_rtcp_packet_fb_get_media_ssrc (packet); | |
| src = find_source (sess, media_ssrc); | |
| /* skip non-bye packets for sources that are marked BYE */ | |
| if (sess->scheduled_bye && src && RTP_SOURCE_IS_MARKED_BYE (src)) | |
| return; | |
| if (src) | |
| g_object_ref (src); | |
| fci_data = gst_rtcp_packet_fb_get_fci (packet); | |
| fci_length = gst_rtcp_packet_fb_get_fci_length (packet) * sizeof (guint32); | |
| GST_DEBUG ("received feedback %d:%d from %08X about %08X with FCI of " | |
| "length %d", type, fbtype, sender_ssrc, media_ssrc, fci_length); | |
| if (g_signal_has_handler_pending (sess, | |
| rtp_session_signals[SIGNAL_ON_FEEDBACK_RTCP], 0, TRUE)) { | |
| GstBuffer *fci_buffer = NULL; | |
| if (fci_length > 0) { | |
| fci_buffer = gst_buffer_copy_region (packet->rtcp->buffer, | |
| GST_BUFFER_COPY_MEMORY, fci_data - packet->rtcp->map.data, | |
| fci_length); | |
| GST_BUFFER_PTS (fci_buffer) = pinfo->running_time; | |
| } | |
| RTP_SESSION_UNLOCK (sess); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_FEEDBACK_RTCP], 0, | |
| type, fbtype, sender_ssrc, media_ssrc, fci_buffer); | |
| RTP_SESSION_LOCK (sess); | |
| if (fci_buffer) | |
| gst_buffer_unref (fci_buffer); | |
| } | |
| if (src && sess->rtcp_feedback_retention_window != GST_CLOCK_TIME_NONE) { | |
| rtp_source_retain_rtcp_packet (src, packet, pinfo->running_time); | |
| } | |
| if ((src && src->internal) || | |
| /* PSFB FIR puts the media ssrc inside the FCI */ | |
| (type == GST_RTCP_TYPE_PSFB && fbtype == GST_RTCP_PSFB_TYPE_FIR) || | |
| /* TWCC is for all sources, so a single media-ssrc is not enough */ | |
| (type == GST_RTCP_TYPE_RTPFB && fbtype == GST_RTCP_RTPFB_TYPE_TWCC)) { | |
| switch (type) { | |
| case GST_RTCP_TYPE_PSFB: | |
| switch (fbtype) { | |
| case GST_RTCP_PSFB_TYPE_PLI: | |
| if (src) | |
| src->stats.recv_pli_count++; | |
| rtp_session_process_pli (sess, sender_ssrc, media_ssrc, | |
| current_time); | |
| break; | |
| case GST_RTCP_PSFB_TYPE_FIR: | |
| if (src) | |
| src->stats.recv_fir_count++; | |
| rtp_session_process_fir (sess, sender_ssrc, fci_data, fci_length, | |
| current_time); | |
| break; | |
| default: | |
| break; | |
| } | |
| break; | |
| case GST_RTCP_TYPE_RTPFB: | |
| switch (fbtype) { | |
| case GST_RTCP_RTPFB_TYPE_NACK: | |
| if (src) | |
| src->stats.recv_nack_count++; | |
| rtp_session_process_nack (sess, sender_ssrc, media_ssrc, | |
| fci_data, fci_length, current_time); | |
| break; | |
| case GST_RTCP_RTPFB_TYPE_RTCP_SR_REQ: | |
| rtp_session_process_sr_req (sess, sender_ssrc, media_ssrc); | |
| break; | |
| case GST_RTCP_RTPFB_TYPE_TWCC: | |
| rtp_session_process_twcc (sess, sender_ssrc, media_ssrc, | |
| fci_data, fci_length); | |
| break; | |
| default: | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| } | |
| if (src) | |
| g_object_unref (src); | |
| } | |
| /** | |
| * rtp_session_process_rtcp: | |
| * @sess: and #RTPSession | |
| * @buffer: an RTCP buffer | |
| * @current_time: the current system time | |
| * @ntpnstime: the current NTP time in nanoseconds | |
| * | |
| * Process an RTCP buffer in the session manager. This function takes ownership | |
| * of @buffer. | |
| * | |
| * Returns: a #GstFlowReturn. | |
| */ | |
| GstFlowReturn | |
| rtp_session_process_rtcp (RTPSession * sess, GstBuffer * buffer, | |
| GstClockTime current_time, GstClockTime running_time, guint64 ntpnstime) | |
| { | |
| GstRTCPPacket packet; | |
| gboolean more, is_bye = FALSE, do_sync = FALSE, has_report = FALSE; | |
| RTPPacketInfo pinfo = { 0, }; | |
| GstFlowReturn result = GST_FLOW_OK; | |
| GstRTCPBuffer rtcp = { NULL, }; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), GST_FLOW_ERROR); | |
| g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR); | |
| if (!gst_rtcp_buffer_validate_reduced (buffer)) | |
| goto invalid_packet; | |
| GST_DEBUG ("received RTCP packet"); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_RECEIVING_RTCP], 0, | |
| buffer); | |
| RTP_SESSION_LOCK (sess); | |
| /* update pinfo stats */ | |
| update_packet_info (sess, &pinfo, FALSE, FALSE, FALSE, buffer, current_time, | |
| running_time, ntpnstime); | |
| /* start processing the compound packet */ | |
| gst_rtcp_buffer_map (buffer, GST_MAP_READ, &rtcp); | |
| more = gst_rtcp_buffer_get_first_packet (&rtcp, &packet); | |
| while (more) { | |
| GstRTCPType type; | |
| type = gst_rtcp_packet_get_type (&packet); | |
| switch (type) { | |
| case GST_RTCP_TYPE_SR: | |
| has_report = TRUE; | |
| rtp_session_process_sr (sess, &packet, &pinfo, &do_sync); | |
| break; | |
| case GST_RTCP_TYPE_RR: | |
| has_report = TRUE; | |
| rtp_session_process_rr (sess, &packet, &pinfo); | |
| break; | |
| case GST_RTCP_TYPE_SDES: | |
| rtp_session_process_sdes (sess, &packet, &pinfo); | |
| break; | |
| case GST_RTCP_TYPE_BYE: | |
| is_bye = TRUE; | |
| /* don't try to attempt lip-sync anymore for streams with a BYE */ | |
| do_sync = FALSE; | |
| rtp_session_process_bye (sess, &packet, &pinfo); | |
| break; | |
| case GST_RTCP_TYPE_APP: | |
| rtp_session_process_app (sess, &packet, &pinfo); | |
| break; | |
| case GST_RTCP_TYPE_RTPFB: | |
| case GST_RTCP_TYPE_PSFB: | |
| rtp_session_process_feedback (sess, &packet, &pinfo, current_time); | |
| break; | |
| case GST_RTCP_TYPE_XR: | |
| /* FIXME: This block is added to downgrade warning level. | |
| * Once the parser is implemented, it should be replaced with | |
| * a proper process function. */ | |
| GST_DEBUG ("got RTCP XR packet, but ignored"); | |
| break; | |
| default: | |
| GST_WARNING ("got unknown RTCP packet type: %d", type); | |
| break; | |
| } | |
| more = gst_rtcp_packet_move_to_next (&packet); | |
| } | |
| gst_rtcp_buffer_unmap (&rtcp); | |
| /* if we are scheduling a BYE, we only want to count bye packets, else we | |
| * count everything */ | |
| if (sess->scheduled_bye && is_bye) { | |
| sess->bye_stats.bye_members++; | |
| UPDATE_AVG (sess->bye_stats.avg_rtcp_packet_size, pinfo.bytes); | |
| } | |
| /* keep track of average packet size */ | |
| UPDATE_AVG (sess->stats.avg_rtcp_packet_size, pinfo.bytes); | |
| GST_DEBUG ("%p, received RTCP packet, avg size %u, %u", &sess->stats, | |
| sess->stats.avg_rtcp_packet_size, pinfo.bytes); | |
| RTP_SESSION_UNLOCK (sess); | |
| if (has_report) { | |
| g_object_notify_by_pspec (G_OBJECT (sess), properties[PROP_STATS]); | |
| } | |
| pinfo.data = NULL; | |
| clean_packet_info (&pinfo); | |
| /* notify caller of sr packets in the callback */ | |
| if (do_sync && sess->callbacks.sync_rtcp) { | |
| result = sess->callbacks.sync_rtcp (sess, buffer, | |
| sess->sync_rtcp_user_data); | |
| } else | |
| gst_buffer_unref (buffer); | |
| return result; | |
| /* ERRORS */ | |
| invalid_packet: | |
| { | |
| GST_DEBUG ("invalid RTCP packet received"); | |
| gst_buffer_unref (buffer); | |
| return GST_FLOW_OK; | |
| } | |
| } | |
| /** | |
| * rtp_session_update_send_caps: | |
| * @sess: an #RTPSession | |
| * @caps: a #GstCaps | |
| * | |
| * Update the caps of the sender in the rtp session. | |
| */ | |
| void | |
| rtp_session_update_send_caps (RTPSession * sess, GstCaps * caps) | |
| { | |
| GstStructure *s; | |
| guint ssrc; | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| g_return_if_fail (GST_IS_CAPS (caps)); | |
| GST_LOG ("received caps %" GST_PTR_FORMAT, caps); | |
| s = gst_caps_get_structure (caps, 0); | |
| if (gst_structure_get_uint (s, "ssrc", &ssrc)) { | |
| RTPSource *source; | |
| gboolean created; | |
| RTP_SESSION_LOCK (sess); | |
| source = obtain_internal_source (sess, ssrc, &created, GST_CLOCK_TIME_NONE); | |
| sess->suggested_ssrc = ssrc; | |
| sess->internal_ssrc_set = TRUE; | |
| sess->internal_ssrc_from_caps_or_property = TRUE; | |
| if (source) { | |
| rtp_source_update_send_caps (source, caps); | |
| if (created) | |
| on_new_sender_ssrc (sess, source); | |
| g_object_unref (source); | |
| } | |
| if (gst_structure_get_uint (s, "rtx-ssrc", &ssrc)) { | |
| source = | |
| obtain_internal_source (sess, ssrc, &created, GST_CLOCK_TIME_NONE); | |
| if (source) { | |
| rtp_source_update_send_caps (source, caps); | |
| if (created) | |
| on_new_sender_ssrc (sess, source); | |
| g_object_unref (source); | |
| } | |
| } | |
| RTP_SESSION_UNLOCK (sess); | |
| } else { | |
| sess->internal_ssrc_from_caps_or_property = FALSE; | |
| } | |
| sess->send_ntp64_ext_id = | |
| gst_rtp_get_extmap_id_for_attribute (s, | |
| GST_RTP_HDREXT_BASE GST_RTP_HDREXT_NTP_64); | |
| rtp_twcc_manager_parse_send_ext_id (sess->twcc, s); | |
| } | |
| static void | |
| update_ntp64_header_ext_data (RTPPacketInfo * pinfo, GstBuffer * buffer) | |
| { | |
| GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; | |
| if (gst_rtp_buffer_map (buffer, GST_MAP_READWRITE, &rtp)) { | |
| guint16 bits; | |
| guint8 *data; | |
| guint wordlen; | |
| if (gst_rtp_buffer_get_extension_data (&rtp, &bits, (gpointer *) & data, | |
| &wordlen)) { | |
| gsize len = wordlen * 4; | |
| /* One-byte header */ | |
| if (bits == 0xBEDE) { | |
| /* One-byte header extension */ | |
| while (TRUE) { | |
| guint8 ext_id, ext_len; | |
| if (len < 1) | |
| break; | |
| ext_id = GST_READ_UINT8 (data) >> 4; | |
| ext_len = (GST_READ_UINT8 (data) & 0xF) + 1; | |
| data += 1; | |
| len -= 1; | |
| if (ext_id == 0) { | |
| /* Skip padding */ | |
| continue; | |
| } else if (ext_id == 15) { | |
| /* Stop parsing */ | |
| break; | |
| } | |
| /* extension doesn't fit into the header */ | |
| if (ext_len > len) | |
| break; | |
| if (ext_id == pinfo->ntp64_ext_id && ext_len == 8) { | |
| if (pinfo->ntpnstime != GST_CLOCK_TIME_NONE) { | |
| guint64 ntptime = gst_util_uint64_scale (pinfo->ntpnstime, | |
| G_GUINT64_CONSTANT (1) << 32, | |
| GST_SECOND); | |
| GST_WRITE_UINT64_BE (data, ntptime); | |
| } else { | |
| /* Replace extension with padding */ | |
| memset (data - 1, 0, 1 + ext_len); | |
| } | |
| } | |
| /* skip to the next extension */ | |
| data += ext_len; | |
| len -= ext_len; | |
| } | |
| } else if ((bits >> 4) == 0x100) { | |
| /* Two-byte header extension */ | |
| while (TRUE) { | |
| guint8 ext_id, ext_len; | |
| if (len < 1) | |
| break; | |
| ext_id = GST_READ_UINT8 (data); | |
| data += 1; | |
| len -= 1; | |
| if (ext_id == 0) { | |
| /* Skip padding */ | |
| continue; | |
| } | |
| ext_len = GST_READ_UINT8 (data); | |
| data += 1; | |
| len -= 1; | |
| /* extension doesn't fit into the header */ | |
| if (ext_len > len) | |
| break; | |
| if (ext_id == pinfo->ntp64_ext_id && ext_len == 8) { | |
| if (pinfo->ntpnstime != GST_CLOCK_TIME_NONE) { | |
| guint64 ntptime = gst_util_uint64_scale (pinfo->ntpnstime, | |
| G_GUINT64_CONSTANT (1) << 32, | |
| GST_SECOND); | |
| GST_WRITE_UINT64_BE (data, ntptime); | |
| } else { | |
| /* Replace extension with padding */ | |
| memset (data - 2, 0, 2 + ext_len); | |
| } | |
| } | |
| /* skip to the next extension */ | |
| data += ext_len; | |
| len -= ext_len; | |
| } | |
| } | |
| } | |
| gst_rtp_buffer_unmap (&rtp); | |
| } | |
| } | |
| static void | |
| update_ntp64_header_ext (RTPPacketInfo * pinfo) | |
| { | |
| /* Early return if we don't know the header extension id or the packets | |
| * don't contain the header extension */ | |
| if (pinfo->ntp64_ext_id == 0 || !pinfo->have_ntp64_ext) | |
| return; | |
| /* If no NTP time is known then the header extension will be replaced with | |
| * padding, otherwise it will be updated */ | |
| GST_TRACE | |
| ("Updating NTP-64 header extension for SSRC %08x packet with RTP time %u and running time %" | |
| GST_TIME_FORMAT " to %" GST_TIME_FORMAT, pinfo->ssrc, pinfo->rtptime, | |
| GST_TIME_ARGS (pinfo->running_time), GST_TIME_ARGS (pinfo->ntpnstime)); | |
| if (GST_IS_BUFFER_LIST (pinfo->data)) { | |
| GstBufferList *list; | |
| guint i = 0; | |
| pinfo->data = gst_buffer_list_make_writable (pinfo->data); | |
| list = GST_BUFFER_LIST (pinfo->data); | |
| for (i = 0; i < gst_buffer_list_length (list); i++) { | |
| GstBuffer *buffer = gst_buffer_list_get_writable (list, i); | |
| update_ntp64_header_ext_data (pinfo, buffer); | |
| } | |
| } else { | |
| pinfo->data = gst_buffer_make_writable (pinfo->data); | |
| update_ntp64_header_ext_data (pinfo, pinfo->data); | |
| } | |
| } | |
| /** | |
| * rtp_session_send_rtp: | |
| * @sess: an #RTPSession | |
| * @data: pointer to either an RTP buffer or a list of RTP buffers | |
| * @is_list: TRUE when @data is a buffer list | |
| * @current_time: the current system time | |
| * @running_time: the running time of @data | |
| * | |
| * Send the RTP data (a buffer or buffer list) in the session manager. This | |
| * function takes ownership of @data. | |
| * | |
| * Returns: a #GstFlowReturn. | |
| */ | |
| GstFlowReturn | |
| rtp_session_send_rtp (RTPSession * sess, gpointer data, gboolean is_list, | |
| GstClockTime current_time, GstClockTime running_time, guint64 ntpnstime) | |
| { | |
| GstFlowReturn result; | |
| RTPSource *source; | |
| gboolean prevsender; | |
| guint64 oldrate; | |
| RTPPacketInfo pinfo = { 0, }; | |
| gboolean created; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), GST_FLOW_ERROR); | |
| g_return_val_if_fail (is_list || GST_IS_BUFFER (data), GST_FLOW_ERROR); | |
| GST_LOG ("received RTP %s for sending", is_list ? "list" : "packet"); | |
| RTP_SESSION_LOCK (sess); | |
| if (!update_packet_info (sess, &pinfo, TRUE, TRUE, is_list, data, | |
| current_time, running_time, ntpnstime)) | |
| goto invalid_packet; | |
| /* Update any 64-bit NTP header extensions with the actual NTP time here */ | |
| if (sess->update_ntp64_header_ext) | |
| update_ntp64_header_ext (&pinfo); | |
| rtp_twcc_manager_send_packet (sess->twcc, &pinfo); | |
| source = obtain_internal_source (sess, pinfo.ssrc, &created, current_time); | |
| if (created) | |
| on_new_sender_ssrc (sess, source); | |
| if (!source->internal) { | |
| GSocketAddress *from; | |
| if (source->rtp_from) | |
| from = source->rtp_from; | |
| else | |
| from = source->rtcp_from; | |
| if (from) { | |
| if (rtp_session_find_conflicting_address (sess, from, current_time)) { | |
| /* Its a known conflict, its probably a loop, not a collision | |
| * lets just drop the incoming packet | |
| */ | |
| GST_LOG ("Our packets are being looped back to us, ignoring collision"); | |
| } else { | |
| GST_DEBUG ("Collision for SSRC %x, change our sender ssrc", pinfo.ssrc); | |
| rtp_session_have_conflict (sess, source, from, current_time); | |
| } | |
| } else { | |
| GST_LOG ("Ignoring collision on sent SSRC %x because remote source" | |
| " doesn't have an address", pinfo.ssrc); | |
| } | |
| /* the the sending source is not internal, we have to drop the packet, | |
| or else we will end up receving it ourselves! */ | |
| goto collision; | |
| } | |
| prevsender = RTP_SOURCE_IS_SENDER (source); | |
| oldrate = source->bitrate; | |
| /* we use our own source to send */ | |
| result = rtp_source_send_rtp (source, &pinfo); | |
| source_update_sender (sess, source, prevsender); | |
| if (oldrate != source->bitrate) | |
| sess->recalc_bandwidth = TRUE; | |
| RTP_SESSION_UNLOCK (sess); | |
| g_object_unref (source); | |
| clean_packet_info (&pinfo); | |
| return result; | |
| invalid_packet: | |
| { | |
| gst_mini_object_unref (GST_MINI_OBJECT_CAST (data)); | |
| RTP_SESSION_UNLOCK (sess); | |
| GST_DEBUG ("invalid RTP packet received"); | |
| return GST_FLOW_OK; | |
| } | |
| collision: | |
| { | |
| g_object_unref (source); | |
| clean_packet_info (&pinfo); | |
| RTP_SESSION_UNLOCK (sess); | |
| GST_WARNING ("non-internal source with same ssrc %08x, drop packet", | |
| pinfo.ssrc); | |
| return GST_FLOW_OK; | |
| } | |
| } | |
| static void | |
| add_bitrates (gpointer key, RTPSource * source, gdouble * bandwidth) | |
| { | |
| *bandwidth += source->bitrate; | |
| } | |
| /* must be called with session lock */ | |
| static GstClockTime | |
| calculate_rtcp_interval (RTPSession * sess, gboolean deterministic, | |
| gboolean first) | |
| { | |
| GstClockTime result; | |
| RTPSessionStats *stats; | |
| /* recalculate bandwidth when it changed */ | |
| if (sess->recalc_bandwidth) { | |
| gdouble bandwidth; | |
| if (sess->bandwidth > 0) | |
| bandwidth = sess->bandwidth; | |
| else { | |
| /* If it is <= 0, then try to estimate the actual bandwidth */ | |
| bandwidth = 0; | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) add_bitrates, &bandwidth); | |
| } | |
| if (bandwidth < RTP_STATS_BANDWIDTH) | |
| bandwidth = RTP_STATS_BANDWIDTH; | |
| rtp_stats_set_bandwidths (&sess->stats, bandwidth, | |
| sess->rtcp_bandwidth, sess->rtcp_rs_bandwidth, sess->rtcp_rr_bandwidth); | |
| sess->recalc_bandwidth = FALSE; | |
| } | |
| if (sess->scheduled_bye) { | |
| stats = &sess->bye_stats; | |
| result = rtp_stats_calculate_bye_interval (stats); | |
| } else { | |
| session_update_ptp (sess); | |
| stats = &sess->stats; | |
| result = rtp_stats_calculate_rtcp_interval (stats, | |
| stats->internal_sender_sources > 0, sess->rtp_profile, | |
| sess->is_doing_ptp, first); | |
| } | |
| GST_DEBUG ("next deterministic interval: %" GST_TIME_FORMAT ", first %d", | |
| GST_TIME_ARGS (result), first); | |
| if (!deterministic && result != GST_CLOCK_TIME_NONE) | |
| result = rtp_stats_add_rtcp_jitter (stats, result); | |
| GST_DEBUG ("next interval: %" GST_TIME_FORMAT, GST_TIME_ARGS (result)); | |
| return result; | |
| } | |
| static void | |
| source_mark_bye (const gchar * key, RTPSource * source, const gchar * reason) | |
| { | |
| if (source->internal) | |
| rtp_source_mark_bye (source, reason); | |
| } | |
| /** | |
| * rtp_session_mark_all_bye: | |
| * @sess: an #RTPSession | |
| * @reason: a reason | |
| * | |
| * Mark all internal sources of the session as BYE with @reason. | |
| */ | |
| void | |
| rtp_session_mark_all_bye (RTPSession * sess, const gchar * reason) | |
| { | |
| g_return_if_fail (RTP_IS_SESSION (sess)); | |
| RTP_SESSION_LOCK (sess); | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) source_mark_bye, (gpointer) reason); | |
| RTP_SESSION_UNLOCK (sess); | |
| } | |
| /* Stop the current @sess and schedule a BYE message for the other members. | |
| * One must have the session lock to call this function | |
| */ | |
| static GstFlowReturn | |
| rtp_session_schedule_bye_locked (RTPSession * sess, GstClockTime current_time) | |
| { | |
| GstFlowReturn result = GST_FLOW_OK; | |
| GstClockTime interval; | |
| /* nothing to do it we already scheduled bye */ | |
| if (sess->scheduled_bye) | |
| goto done; | |
| /* we schedule BYE now */ | |
| sess->scheduled_bye = TRUE; | |
| /* at least one member wants to send a BYE */ | |
| memcpy (&sess->bye_stats, &sess->stats, sizeof (RTPSessionStats)); | |
| INIT_AVG (sess->bye_stats.avg_rtcp_packet_size, 100); | |
| sess->bye_stats.bye_members = 1; | |
| sess->first_rtcp = TRUE; | |
| /* reschedule transmission */ | |
| sess->last_rtcp_send_time = current_time; | |
| sess->last_rtcp_check_time = current_time; | |
| interval = calculate_rtcp_interval (sess, FALSE, TRUE); | |
| if (interval != GST_CLOCK_TIME_NONE) | |
| sess->next_rtcp_check_time = current_time + interval; | |
| else | |
| sess->next_rtcp_check_time = GST_CLOCK_TIME_NONE; | |
| sess->last_rtcp_interval = interval; | |
| GST_DEBUG ("Schedule BYE for %" GST_TIME_FORMAT ", %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (interval), GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| RTP_SESSION_UNLOCK (sess); | |
| /* notify app of reconsideration */ | |
| if (sess->callbacks.reconsider) | |
| sess->callbacks.reconsider (sess, sess->reconsider_user_data); | |
| RTP_SESSION_LOCK (sess); | |
| done: | |
| return result; | |
| } | |
| /** | |
| * rtp_session_schedule_bye: | |
| * @sess: an #RTPSession | |
| * @current_time: the current system time | |
| * | |
| * Schedule a BYE message for all sources marked as BYE in @sess. | |
| * | |
| * Returns: a #GstFlowReturn. | |
| */ | |
| GstFlowReturn | |
| rtp_session_schedule_bye (RTPSession * sess, GstClockTime current_time) | |
| { | |
| GstFlowReturn result; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), GST_FLOW_ERROR); | |
| RTP_SESSION_LOCK (sess); | |
| result = rtp_session_schedule_bye_locked (sess, current_time); | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_next_timeout: | |
| * @sess: an #RTPSession | |
| * @current_time: the current system time | |
| * | |
| * Get the next time we should perform session maintenance tasks. | |
| * | |
| * Returns: a time when rtp_session_on_timeout() should be called with the | |
| * current system time. | |
| */ | |
| GstClockTime | |
| rtp_session_next_timeout (RTPSession * sess, GstClockTime current_time) | |
| { | |
| GstClockTime result, interval = 0; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), GST_CLOCK_TIME_NONE); | |
| RTP_SESSION_LOCK (sess); | |
| if (GST_CLOCK_TIME_IS_VALID (sess->next_early_rtcp_time)) { | |
| GST_DEBUG ("have early rtcp time"); | |
| result = sess->next_early_rtcp_time; | |
| goto early_exit; | |
| } | |
| result = sess->next_rtcp_check_time; | |
| GST_DEBUG ("current time: %" GST_TIME_FORMAT | |
| ", next time: %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (current_time), GST_TIME_ARGS (result)); | |
| if (result == GST_CLOCK_TIME_NONE || result < current_time) { | |
| GST_DEBUG ("take current time as base"); | |
| /* our previous check time expired, start counting from the current time | |
| * again. */ | |
| result = current_time; | |
| } | |
| if (sess->scheduled_bye) { | |
| if (sess->bye_stats.active_sources >= 50) { | |
| GST_DEBUG ("reconsider BYE, more than 50 sources"); | |
| /* reconsider BYE if members >= 50 */ | |
| interval = calculate_rtcp_interval (sess, FALSE, TRUE); | |
| sess->last_rtcp_interval = interval; | |
| } | |
| } else { | |
| if (sess->first_rtcp) { | |
| GST_DEBUG ("first RTCP packet"); | |
| /* we are called for the first time */ | |
| interval = calculate_rtcp_interval (sess, FALSE, TRUE); | |
| sess->last_rtcp_interval = interval; | |
| } else if (sess->next_rtcp_check_time < current_time) { | |
| GST_DEBUG ("old check time expired, getting new timeout"); | |
| /* get a new timeout when we need to */ | |
| interval = calculate_rtcp_interval (sess, FALSE, FALSE); | |
| sess->last_rtcp_interval = interval; | |
| if ((sess->rtp_profile == GST_RTP_PROFILE_AVPF | |
| || sess->rtp_profile == GST_RTP_PROFILE_SAVPF) | |
| && interval != GST_CLOCK_TIME_NONE) { | |
| /* Apply the rules from RFC 4585 section 3.5.3 */ | |
| if (sess->stats.min_interval != 0) { | |
| GstClockTime T_rr_current_interval = g_random_double_range (0.5, | |
| 1.5) * sess->stats.min_interval * GST_SECOND; | |
| if (T_rr_current_interval > interval) { | |
| GST_DEBUG ("Adjusting interval for t-rr-interval: %" GST_TIME_FORMAT | |
| " > %" GST_TIME_FORMAT, GST_TIME_ARGS (T_rr_current_interval), | |
| GST_TIME_ARGS (interval)); | |
| interval = T_rr_current_interval; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (interval != GST_CLOCK_TIME_NONE) | |
| result += interval; | |
| else | |
| result = GST_CLOCK_TIME_NONE; | |
| sess->next_rtcp_check_time = result; | |
| early_exit: | |
| GST_DEBUG ("current time: %" GST_TIME_FORMAT | |
| ", next time: %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (current_time), GST_TIME_ARGS (result)); | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| typedef struct | |
| { | |
| RTPSource *source; | |
| gboolean is_bye; | |
| GstBuffer *buffer; | |
| } ReportOutput; | |
| typedef struct | |
| { | |
| GstRTCPBuffer rtcpbuf; | |
| RTPSession *sess; | |
| RTPSource *source; | |
| guint num_to_report; | |
| gboolean have_fir; | |
| gboolean have_pli; | |
| gboolean have_nack; | |
| GstBuffer *rtcp; | |
| GstClockTime current_time; | |
| guint64 ntpnstime; | |
| GstClockTime running_time; | |
| GstClockTime interval; | |
| GstRTCPPacket packet; | |
| gboolean has_sdes; | |
| gboolean is_early; | |
| GQueue output; | |
| guint nacked_seqnums; | |
| gboolean timeout_inactive_sources; | |
| } ReportData; | |
| static gboolean | |
| session_start_rtcp (RTPSession * sess, ReportData * data) | |
| { | |
| GstRTCPPacket *packet = &data->packet; | |
| RTPSource *own = data->source; | |
| GstRTCPBuffer *rtcp = &data->rtcpbuf; | |
| data->rtcp = gst_rtcp_buffer_new (sess->mtu); | |
| data->has_sdes = FALSE; | |
| gst_rtcp_buffer_map (data->rtcp, GST_MAP_READWRITE, rtcp); | |
| if (RTP_SOURCE_IS_SENDER (own) && (!data->is_early || !sess->reduced_size_rtcp | |
| || sess->sr_req_pending)) { | |
| guint64 ntptime; | |
| guint32 rtptime; | |
| guint32 packet_count, octet_count; | |
| sess->sr_req_pending = FALSE; | |
| /* we are a sender, create SR */ | |
| GST_DEBUG ("create SR for SSRC %08x", own->ssrc); | |
| gst_rtcp_buffer_add_packet (rtcp, GST_RTCP_TYPE_SR, packet); | |
| /* get latest stats */ | |
| if (!rtp_source_get_new_sr (own, data->ntpnstime, data->running_time, | |
| &ntptime, &rtptime, &packet_count, &octet_count)) { | |
| gst_rtcp_buffer_unmap (&data->rtcpbuf); | |
| return FALSE; | |
| } | |
| /* store stats */ | |
| rtp_source_process_sr (own, data->current_time, ntptime, rtptime, | |
| packet_count, octet_count); | |
| /* fill in sender report info */ | |
| gst_rtcp_packet_sr_set_sender_info (packet, own->ssrc, | |
| sess->timestamp_sender_reports ? ntptime : 0, | |
| sess->timestamp_sender_reports ? rtptime : 0, | |
| packet_count, octet_count); | |
| } else if (!data->is_early || !sess->reduced_size_rtcp) { | |
| /* we are only receiver, create RR */ | |
| GST_DEBUG ("create RR for SSRC %08x", own->ssrc); | |
| gst_rtcp_buffer_add_packet (rtcp, GST_RTCP_TYPE_RR, packet); | |
| gst_rtcp_packet_rr_set_ssrc (packet, own->ssrc); | |
| } | |
| return TRUE; | |
| } | |
| /* construct a Sender or Receiver Report */ | |
| static void | |
| session_report_blocks (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| RTPSession *sess = data->sess; | |
| GstRTCPPacket *packet = &data->packet; | |
| guint8 fractionlost; | |
| gint32 packetslost; | |
| guint32 exthighestseq, jitter; | |
| guint32 lsr, dlsr; | |
| /* don't report for sources in future generations */ | |
| if (((gint16) (source->generation - sess->generation)) > 0) { | |
| GST_DEBUG ("source %08x generation %u > %u", source->ssrc, | |
| source->generation, sess->generation); | |
| return; | |
| } | |
| if (g_hash_table_contains (source->reported_in_sr_of, | |
| GUINT_TO_POINTER (data->source->ssrc))) { | |
| GST_DEBUG ("source %08x already reported in this generation", source->ssrc); | |
| return; | |
| } | |
| if (gst_rtcp_packet_get_rb_count (packet) == GST_RTCP_MAX_RB_COUNT) { | |
| GST_DEBUG ("max RB count reached"); | |
| return; | |
| } | |
| /* only report about remote sources */ | |
| if (source->internal) | |
| goto reported; | |
| if (!RTP_SOURCE_IS_SENDER (source)) { | |
| GST_DEBUG ("source %08x not sender", source->ssrc); | |
| goto reported; | |
| } | |
| if (source->disable_rtcp) { | |
| GST_DEBUG ("source %08x has RTCP disabled", source->ssrc); | |
| goto reported; | |
| } | |
| GST_DEBUG ("create RB for SSRC %08x", source->ssrc); | |
| /* get new stats */ | |
| rtp_source_get_new_rb (source, data->current_time, &fractionlost, | |
| &packetslost, &exthighestseq, &jitter, &lsr, &dlsr); | |
| /* store last generated RR packet */ | |
| source->last_rr.is_valid = TRUE; | |
| source->last_rr.ssrc = data->source->ssrc; | |
| source->last_rr.fractionlost = fractionlost; | |
| source->last_rr.packetslost = packetslost; | |
| source->last_rr.exthighestseq = exthighestseq; | |
| source->last_rr.jitter = jitter; | |
| source->last_rr.lsr = lsr; | |
| source->last_rr.dlsr = dlsr; | |
| /* packet is not yet filled, add report block for this source. */ | |
| gst_rtcp_packet_add_rb (packet, source->ssrc, fractionlost, packetslost, | |
| exthighestseq, jitter, lsr, dlsr); | |
| reported: | |
| g_hash_table_add (source->reported_in_sr_of, | |
| GUINT_TO_POINTER (data->source->ssrc)); | |
| } | |
| /* construct FIR */ | |
| static void | |
| session_add_fir (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| GstRTCPPacket *packet = &data->packet; | |
| guint16 len; | |
| guint8 *fci_data; | |
| if (!source->send_fir) | |
| return; | |
| len = gst_rtcp_packet_fb_get_fci_length (packet); | |
| if (!gst_rtcp_packet_fb_set_fci_length (packet, len + 2)) | |
| /* exit because the packet is full, will put next request in a | |
| * further packet */ | |
| return; | |
| fci_data = gst_rtcp_packet_fb_get_fci (packet) + (len * 4); | |
| GST_WRITE_UINT32_BE (fci_data, source->ssrc); | |
| fci_data += 4; | |
| fci_data[0] = source->current_send_fir_seqnum; | |
| fci_data[1] = fci_data[2] = fci_data[3] = 0; | |
| source->send_fir = FALSE; | |
| source->stats.sent_fir_count++; | |
| } | |
| static void | |
| session_fir (RTPSession * sess, ReportData * data) | |
| { | |
| GstRTCPBuffer *rtcp = &data->rtcpbuf; | |
| GstRTCPPacket *packet = &data->packet; | |
| if (!gst_rtcp_buffer_add_packet (rtcp, GST_RTCP_TYPE_PSFB, packet)) | |
| return; | |
| gst_rtcp_packet_fb_set_type (packet, GST_RTCP_PSFB_TYPE_FIR); | |
| gst_rtcp_packet_fb_set_sender_ssrc (packet, data->source->ssrc); | |
| gst_rtcp_packet_fb_set_media_ssrc (packet, 0); | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) session_add_fir, data); | |
| if (gst_rtcp_packet_fb_get_fci_length (packet) == 0) | |
| gst_rtcp_packet_remove (packet); | |
| } | |
| static gboolean | |
| has_pli_compare_func (gconstpointer a, gconstpointer ignored) | |
| { | |
| GstRTCPPacket packet; | |
| GstRTCPBuffer rtcp = { NULL, }; | |
| gboolean ret = FALSE; | |
| gst_rtcp_buffer_map ((GstBuffer *) a, GST_MAP_READ, &rtcp); | |
| if (gst_rtcp_buffer_get_first_packet (&rtcp, &packet)) { | |
| if (gst_rtcp_packet_get_type (&packet) == GST_RTCP_TYPE_PSFB && | |
| gst_rtcp_packet_fb_get_type (&packet) == GST_RTCP_PSFB_TYPE_PLI) | |
| ret = TRUE; | |
| } | |
| gst_rtcp_buffer_unmap (&rtcp); | |
| return ret; | |
| } | |
| /* construct PLI */ | |
| static void | |
| session_pli (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| GstRTCPBuffer *rtcp = &data->rtcpbuf; | |
| GstRTCPPacket *packet = &data->packet; | |
| if (!source->send_pli) | |
| return; | |
| if (rtp_source_has_retained (source, has_pli_compare_func, NULL)) | |
| return; | |
| if (!gst_rtcp_buffer_add_packet (rtcp, GST_RTCP_TYPE_PSFB, packet)) | |
| /* exit because the packet is full, will put next request in a | |
| * further packet */ | |
| return; | |
| gst_rtcp_packet_fb_set_type (packet, GST_RTCP_PSFB_TYPE_PLI); | |
| gst_rtcp_packet_fb_set_sender_ssrc (packet, data->source->ssrc); | |
| gst_rtcp_packet_fb_set_media_ssrc (packet, source->ssrc); | |
| source->send_pli = FALSE; | |
| source->stats.sent_pli_count++; | |
| } | |
| /* construct NACK */ | |
| static void | |
| session_nack (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| RTPSession *sess = data->sess; | |
| GstRTCPBuffer *rtcp = &data->rtcpbuf; | |
| GstRTCPPacket *packet = &data->packet; | |
| guint16 *nacks; | |
| GstClockTime *nack_deadlines; | |
| guint n_nacks, i = 0; | |
| guint nacked_seqnums = 0; | |
| guint16 n_fb_nacks = 0; | |
| guint8 *fci_data; | |
| if (!source->send_nack) | |
| return; | |
| nacks = rtp_source_get_nacks (source, &n_nacks); | |
| nack_deadlines = rtp_source_get_nack_deadlines (source, NULL); | |
| GST_DEBUG ("%u NACKs current time %" GST_TIME_FORMAT, n_nacks, | |
| GST_TIME_ARGS (data->current_time)); | |
| /* cleanup expired nacks */ | |
| for (i = 0; i < n_nacks; i++) { | |
| GST_DEBUG ("#%u deadline %" GST_TIME_FORMAT, nacks[i], | |
| GST_TIME_ARGS (nack_deadlines[i])); | |
| if (nack_deadlines[i] >= data->current_time) | |
| break; | |
| } | |
| if (data->is_early) { | |
| /* don't remove them all if this is an early RTCP packet. It may happen | |
| * that the NACKs are late due to high RTT, not sending NACKs at all would | |
| * keep the RTX RTT stats high and maintain a dropping state. */ | |
| i = MIN (n_nacks - 1, i); | |
| } | |
| if (i) { | |
| GST_WARNING ("Removing %u expired NACKS", i); | |
| rtp_source_clear_nacks (source, i); | |
| n_nacks -= i; | |
| if (n_nacks == 0) | |
| return; | |
| } | |
| /* allow overriding NACK to packet conversion */ | |
| if (g_signal_has_handler_pending (sess, | |
| rtp_session_signals[SIGNAL_ON_SENDING_NACKS], 0, TRUE)) { | |
| /* this is needed as it will actually resize the buffer */ | |
| gst_rtcp_buffer_unmap (rtcp); | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SENDING_NACKS], 0, | |
| data->source->ssrc, source->ssrc, source->nacks, data->rtcp, | |
| &nacked_seqnums); | |
| /* and now remap for the remaining work */ | |
| gst_rtcp_buffer_map (data->rtcp, GST_MAP_READWRITE, rtcp); | |
| if (nacked_seqnums > 0) | |
| goto done; | |
| } | |
| if (!gst_rtcp_buffer_add_packet (rtcp, GST_RTCP_TYPE_RTPFB, packet)) | |
| /* exit because the packet is full, will put next request in a | |
| * further packet */ | |
| return; | |
| gst_rtcp_packet_fb_set_type (packet, GST_RTCP_RTPFB_TYPE_NACK); | |
| gst_rtcp_packet_fb_set_sender_ssrc (packet, data->source->ssrc); | |
| gst_rtcp_packet_fb_set_media_ssrc (packet, source->ssrc); | |
| if (!gst_rtcp_packet_fb_set_fci_length (packet, 1)) { | |
| gst_rtcp_packet_remove (packet); | |
| GST_WARNING ("no nacks fit in the packet"); | |
| return; | |
| } | |
| fci_data = gst_rtcp_packet_fb_get_fci (packet); | |
| for (i = 0; i < n_nacks; i = nacked_seqnums) { | |
| guint16 seqnum = nacks[i]; | |
| guint16 blp = 0; | |
| guint j; | |
| if (!gst_rtcp_packet_fb_set_fci_length (packet, n_fb_nacks + 1)) | |
| break; | |
| n_fb_nacks++; | |
| nacked_seqnums++; | |
| for (j = i + 1; j < n_nacks; j++) { | |
| gint diff; | |
| diff = gst_rtp_buffer_compare_seqnum (seqnum, nacks[j]); | |
| GST_TRACE ("[%u][%u] %u %u diff %i", i, j, seqnum, nacks[j], diff); | |
| if (diff > 16) | |
| break; | |
| blp |= 1 << (diff - 1); | |
| nacked_seqnums++; | |
| } | |
| GST_WRITE_UINT32_BE (fci_data, seqnum << 16 | blp); | |
| fci_data += 4; | |
| } | |
| GST_DEBUG ("Sent %u seqnums into %u FB NACKs", nacked_seqnums, n_fb_nacks); | |
| source->stats.sent_nack_count += n_fb_nacks; | |
| done: | |
| data->nacked_seqnums += nacked_seqnums; | |
| rtp_source_clear_nacks (source, nacked_seqnums); | |
| } | |
| /* perform cleanup of sources that timed out */ | |
| static void | |
| session_cleanup (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| gboolean remove = FALSE; | |
| gboolean byetimeout = FALSE; | |
| gboolean sendertimeout = FALSE; | |
| gboolean is_sender, is_active; | |
| RTPSession *sess = data->sess; | |
| GstClockTime interval, binterval; | |
| GstClockTime btime; | |
| GST_DEBUG ("look at %08x, generation %u", source->ssrc, source->generation); | |
| /* check for outdated collisions */ | |
| if (source->internal) { | |
| GST_DEBUG ("Timing out collisions for %x", source->ssrc); | |
| rtp_source_timeout (source, data->current_time, data->running_time, | |
| sess->rtcp_feedback_retention_window); | |
| } | |
| /* nothing else to do when without RTCP */ | |
| if (data->interval == GST_CLOCK_TIME_NONE) | |
| return; | |
| is_sender = RTP_SOURCE_IS_SENDER (source); | |
| is_active = RTP_SOURCE_IS_ACTIVE (source); | |
| /* our own rtcp interval may have been forced low by secondary configuration, | |
| * while sender side may still operate with higher interval, | |
| * so do not just take our interval to decide on timing out sender, | |
| * but take (if data->interval <= 5 * GST_SECOND): | |
| * interval = CLAMP (sender_interval, data->interval, 5 * GST_SECOND) | |
| * where sender_interval is difference between last 2 received RTCP reports | |
| */ | |
| if (data->interval >= 5 * GST_SECOND || source->internal) { | |
| binterval = data->interval; | |
| } else { | |
| GST_LOG ("prev_rtcp %" GST_TIME_FORMAT ", last_rtcp %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (source->stats.prev_rtcptime), | |
| GST_TIME_ARGS (source->stats.last_rtcptime)); | |
| /* if not received enough yet, fallback to larger default */ | |
| if (source->stats.last_rtcptime > source->stats.prev_rtcptime) | |
| binterval = source->stats.last_rtcptime - source->stats.prev_rtcptime; | |
| else | |
| binterval = 5 * GST_SECOND; | |
| binterval = CLAMP (binterval, data->interval, 5 * GST_SECOND); | |
| } | |
| GST_LOG ("timeout base interval %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (binterval)); | |
| if (!source->internal && source->marked_bye) { | |
| /* if we received a BYE from the source, remove the source after some | |
| * time. */ | |
| if (data->current_time > source->bye_time && | |
| data->current_time - source->bye_time > sess->stats.bye_timeout) { | |
| GST_DEBUG ("removing BYE source %08x", source->ssrc); | |
| remove = TRUE; | |
| byetimeout = TRUE; | |
| } | |
| } | |
| if (source->internal && source->sent_bye) { | |
| GST_DEBUG ("removing internal source that has sent BYE %08x", source->ssrc); | |
| remove = TRUE; | |
| } | |
| if (data->timeout_inactive_sources) { | |
| /* sources that were inactive for more than 5 times the deterministic reporting | |
| * interval get timed out. the min timeout is 5 seconds. */ | |
| /* mind old time that might pre-date last time going to PLAYING */ | |
| btime = MAX (source->last_activity, sess->start_time); | |
| if (data->current_time > btime) { | |
| interval = MAX (binterval * 5, 5 * GST_SECOND); | |
| if (data->current_time - btime > interval) { | |
| GST_DEBUG ("removing timeout source %08x, last %" GST_TIME_FORMAT, | |
| source->ssrc, GST_TIME_ARGS (btime)); | |
| if (source->internal) { | |
| /* this is an internal source that is not using our suggested ssrc. | |
| * since there must be another source using this ssrc, we can remove | |
| * this one instead of making it a receiver forever */ | |
| if (source->ssrc != sess->suggested_ssrc | |
| && source->media_ssrc != sess->suggested_ssrc) { | |
| rtp_source_mark_bye (source, "timed out"); | |
| /* do not schedule bye here, since we are inside the RTCP timeout | |
| * processing and scheduling bye will interfere with SR/RR sending */ | |
| } | |
| } else { | |
| remove = TRUE; | |
| } | |
| } | |
| } | |
| } | |
| /* senders that did not send for a long time become a receiver, this also | |
| * holds for our own sources. */ | |
| if (is_sender) { | |
| /* mind old time that might pre-date last time going to PLAYING */ | |
| btime = MAX (source->last_rtp_activity, sess->start_time); | |
| if (data->current_time > btime) { | |
| interval = MAX (binterval * 2, 5 * GST_SECOND); | |
| if (data->current_time - btime > interval) { | |
| GST_DEBUG ("sender source %08x timed out and became receiver, last %" | |
| GST_TIME_FORMAT, source->ssrc, GST_TIME_ARGS (btime)); | |
| sendertimeout = TRUE; | |
| } | |
| } | |
| } | |
| if (remove) { | |
| sess->total_sources--; | |
| if (is_sender) { | |
| sess->stats.sender_sources--; | |
| if (source->internal) | |
| sess->stats.internal_sender_sources--; | |
| } | |
| if (is_active) | |
| sess->stats.active_sources--; | |
| if (source->internal) | |
| sess->stats.internal_sources--; | |
| if (byetimeout) | |
| on_bye_timeout (sess, source); | |
| else | |
| on_timeout (sess, source); | |
| } else { | |
| if (sendertimeout) { | |
| source->is_sender = FALSE; | |
| sess->stats.sender_sources--; | |
| if (source->internal) | |
| sess->stats.internal_sender_sources--; | |
| on_sender_timeout (sess, source); | |
| } | |
| /* count how many source to report in this generation */ | |
| if (((gint16) (source->generation - sess->generation)) <= 0) | |
| data->num_to_report++; | |
| } | |
| source->closing = remove; | |
| } | |
| static void | |
| session_sdes (RTPSession * sess, ReportData * data) | |
| { | |
| GstRTCPPacket *packet = &data->packet; | |
| const GstStructure *sdes; | |
| gint i, n_fields; | |
| GstRTCPBuffer *rtcp = &data->rtcpbuf; | |
| /* add SDES packet */ | |
| gst_rtcp_buffer_add_packet (rtcp, GST_RTCP_TYPE_SDES, packet); | |
| gst_rtcp_packet_sdes_add_item (packet, data->source->ssrc); | |
| sdes = rtp_source_get_sdes_struct (data->source); | |
| /* add all fields in the structure, the order is not important. */ | |
| n_fields = gst_structure_n_fields (sdes); | |
| for (i = 0; i < n_fields; ++i) { | |
| const gchar *field; | |
| const gchar *value; | |
| GstRTCPSDESType type; | |
| field = gst_structure_nth_field_name (sdes, i); | |
| if (field == NULL) | |
| continue; | |
| value = gst_structure_get_string (sdes, field); | |
| if (value == NULL) | |
| continue; | |
| type = gst_rtcp_sdes_name_to_type (field); | |
| /* Early packets are minimal and only include the CNAME */ | |
| if (data->is_early && type != GST_RTCP_SDES_CNAME) | |
| continue; | |
| if (type > GST_RTCP_SDES_END && type < GST_RTCP_SDES_PRIV) { | |
| gst_rtcp_packet_sdes_add_entry (packet, type, strlen (value), | |
| (const guint8 *) value); | |
| } else if (type == GST_RTCP_SDES_PRIV) { | |
| gsize prefix_len; | |
| gsize value_len; | |
| gsize data_len; | |
| guint8 data[256]; | |
| /* don't accept entries that are too big */ | |
| prefix_len = strlen (field); | |
| if (prefix_len > 255) | |
| continue; | |
| value_len = strlen (value); | |
| if (value_len > 255) | |
| continue; | |
| data_len = 1 + prefix_len + value_len; | |
| if (data_len > 255) | |
| continue; | |
| data[0] = prefix_len; | |
| memcpy (&data[1], field, prefix_len); | |
| memcpy (&data[1 + prefix_len], value, value_len); | |
| gst_rtcp_packet_sdes_add_entry (packet, type, data_len, data); | |
| } | |
| } | |
| data->has_sdes = TRUE; | |
| } | |
| /* schedule a BYE packet */ | |
| static void | |
| make_source_bye (RTPSession * sess, RTPSource * source, ReportData * data) | |
| { | |
| GstRTCPPacket *packet = &data->packet; | |
| GstRTCPBuffer *rtcp = &data->rtcpbuf; | |
| /* add SDES */ | |
| session_sdes (sess, data); | |
| /* add a BYE packet */ | |
| gst_rtcp_buffer_add_packet (rtcp, GST_RTCP_TYPE_BYE, packet); | |
| gst_rtcp_packet_bye_add_ssrc (packet, source->ssrc); | |
| if (source->bye_reason) | |
| gst_rtcp_packet_bye_set_reason (packet, source->bye_reason); | |
| /* we have a BYE packet now */ | |
| source->sent_bye = TRUE; | |
| } | |
| static gboolean | |
| is_rtcp_time (RTPSession * sess, GstClockTime current_time, ReportData * data) | |
| { | |
| GstClockTime new_send_time; | |
| GstClockTime interval; | |
| RTPSessionStats *stats; | |
| if (sess->scheduled_bye) | |
| stats = &sess->bye_stats; | |
| else | |
| stats = &sess->stats; | |
| if (GST_CLOCK_TIME_IS_VALID (sess->next_early_rtcp_time)) | |
| data->is_early = TRUE; | |
| else | |
| data->is_early = FALSE; | |
| if (data->is_early && sess->next_early_rtcp_time <= current_time) { | |
| GST_DEBUG ("early feedback %" GST_TIME_FORMAT " <= now %" | |
| GST_TIME_FORMAT, GST_TIME_ARGS (sess->next_early_rtcp_time), | |
| GST_TIME_ARGS (current_time)); | |
| } else if (sess->next_rtcp_check_time == GST_CLOCK_TIME_NONE || | |
| sess->next_rtcp_check_time > current_time) { | |
| GST_DEBUG ("no check time yet, next %" GST_TIME_FORMAT " > now %" | |
| GST_TIME_FORMAT, GST_TIME_ARGS (sess->next_rtcp_check_time), | |
| GST_TIME_ARGS (current_time)); | |
| return FALSE; | |
| } | |
| /* take interval and add jitter */ | |
| interval = data->interval; | |
| if (interval != GST_CLOCK_TIME_NONE) | |
| interval = rtp_stats_add_rtcp_jitter (stats, interval); | |
| if (sess->last_rtcp_check_time != GST_CLOCK_TIME_NONE) { | |
| /* perform forward reconsideration */ | |
| if (interval != GST_CLOCK_TIME_NONE) { | |
| GstClockTime elapsed; | |
| /* get elapsed time since we last reported */ | |
| elapsed = current_time - sess->last_rtcp_check_time; | |
| GST_DEBUG ("forward reconsideration %" GST_TIME_FORMAT ", elapsed %" | |
| GST_TIME_FORMAT, GST_TIME_ARGS (interval), GST_TIME_ARGS (elapsed)); | |
| new_send_time = interval + sess->last_rtcp_check_time; | |
| } else { | |
| new_send_time = sess->last_rtcp_check_time; | |
| } | |
| } else { | |
| /* If this is the first RTCP packet, we can reconsider anything based | |
| * on the last RTCP send time because there was none. | |
| */ | |
| g_warn_if_fail (!data->is_early); | |
| data->is_early = FALSE; | |
| new_send_time = current_time; | |
| } | |
| if (!data->is_early) { | |
| /* check if reconsideration */ | |
| if (new_send_time == GST_CLOCK_TIME_NONE || current_time < new_send_time) { | |
| GST_DEBUG ("reconsider RTCP for %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (new_send_time)); | |
| /* store new check time */ | |
| sess->next_rtcp_check_time = new_send_time; | |
| sess->last_rtcp_interval = interval; | |
| return FALSE; | |
| } | |
| sess->last_rtcp_interval = interval; | |
| if ((sess->rtp_profile == GST_RTP_PROFILE_AVPF | |
| || sess->rtp_profile == GST_RTP_PROFILE_SAVPF) | |
| && interval != GST_CLOCK_TIME_NONE) { | |
| /* Apply the rules from RFC 4585 section 3.5.3 */ | |
| if (stats->min_interval != 0 && !sess->first_rtcp) { | |
| GstClockTime T_rr_current_interval = | |
| g_random_double_range (0.5, 1.5) * stats->min_interval * GST_SECOND; | |
| if (T_rr_current_interval > interval) { | |
| GST_DEBUG ("Adjusting interval for t-rr-interval: %" GST_TIME_FORMAT | |
| " > %" GST_TIME_FORMAT, GST_TIME_ARGS (T_rr_current_interval), | |
| GST_TIME_ARGS (interval)); | |
| interval = T_rr_current_interval; | |
| } | |
| } | |
| } | |
| sess->next_rtcp_check_time = current_time + interval; | |
| } | |
| GST_DEBUG ("can send RTCP now, next %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| return TRUE; | |
| } | |
| static void | |
| clone_ssrcs_hashtable (gchar * key, RTPSource * source, GHashTable * hash_table) | |
| { | |
| g_hash_table_insert (hash_table, key, g_object_ref (source)); | |
| } | |
| static gboolean | |
| remove_closing_sources (const gchar * key, RTPSource * source, | |
| ReportData * data) | |
| { | |
| if (source->closing) | |
| return TRUE; | |
| if (source->send_fir) | |
| data->have_fir = TRUE; | |
| if (source->send_pli) | |
| data->have_pli = TRUE; | |
| if (source->send_nack) | |
| data->have_nack = TRUE; | |
| return FALSE; | |
| } | |
| static void | |
| generate_twcc (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| RTPSession *sess = data->sess; | |
| GstBuffer *buf; | |
| /* only generate RTCP for active internal sources */ | |
| if (!source->internal || source->sent_bye) | |
| return; | |
| /* ignore other sources when we do the timeout after a scheduled BYE */ | |
| if (sess->scheduled_bye && !source->marked_bye) | |
| return; | |
| /* skip if RTCP is disabled */ | |
| if (source->disable_rtcp) { | |
| GST_DEBUG ("source %08x has RTCP disabled", source->ssrc); | |
| return; | |
| } | |
| GST_DEBUG ("generating TWCC feedback for source %08x", source->ssrc); | |
| while ((buf = rtp_twcc_manager_get_feedback (sess->twcc, source->ssrc))) { | |
| ReportOutput *output = g_new (ReportOutput, 1); | |
| output->source = g_object_ref (source); | |
| output->is_bye = FALSE; | |
| output->buffer = buf; | |
| /* queue the RTCP packet to push later */ | |
| g_queue_push_tail (&data->output, output); | |
| } | |
| } | |
| static void | |
| generate_rtcp (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| RTPSession *sess = data->sess; | |
| gboolean is_bye = FALSE; | |
| ReportOutput *output; | |
| gboolean sr_req_pending = sess->sr_req_pending; | |
| /* only generate RTCP for active internal sources */ | |
| if (!source->internal || source->sent_bye) | |
| return; | |
| /* ignore other sources when we do the timeout after a scheduled BYE */ | |
| if (sess->scheduled_bye && !source->marked_bye) | |
| return; | |
| /* skip if RTCP is disabled */ | |
| if (source->disable_rtcp) { | |
| GST_DEBUG ("source %08x has RTCP disabled", source->ssrc); | |
| return; | |
| } | |
| data->source = source; | |
| /* open packet */ | |
| if (!session_start_rtcp (sess, data)) { | |
| GST_WARNING ("source %08x can not generate RTCP", source->ssrc); | |
| return; | |
| } | |
| if (source->marked_bye) { | |
| /* send BYE */ | |
| make_source_bye (sess, source, data); | |
| is_bye = TRUE; | |
| } else if (!data->is_early) { | |
| /* loop over all known sources and add report blocks. If we are early, we | |
| * just make a minimal RTCP packet and skip this step */ | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) session_report_blocks, data); | |
| } | |
| if (!data->has_sdes && (!data->is_early || !sess->reduced_size_rtcp | |
| || sr_req_pending)) | |
| session_sdes (sess, data); | |
| if (data->have_fir) | |
| session_fir (sess, data); | |
| if (data->have_pli) | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) session_pli, data); | |
| if (data->have_nack) | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) session_nack, data); | |
| gst_rtcp_buffer_unmap (&data->rtcpbuf); | |
| output = g_new (ReportOutput, 1); | |
| output->source = g_object_ref (source); | |
| output->is_bye = is_bye; | |
| output->buffer = data->rtcp; | |
| /* queue the RTCP packet to push later */ | |
| g_queue_push_tail (&data->output, output); | |
| } | |
| static void | |
| update_generation (const gchar * key, RTPSource * source, ReportData * data) | |
| { | |
| RTPSession *sess = data->sess; | |
| if (g_hash_table_size (source->reported_in_sr_of) >= | |
| sess->stats.internal_sources) { | |
| /* source is reported, move to next generation */ | |
| source->generation = sess->generation + 1; | |
| g_hash_table_remove_all (source->reported_in_sr_of); | |
| GST_LOG ("reported source %x, new generation: %d", source->ssrc, | |
| source->generation); | |
| /* if we reported all sources in this generation, move to next */ | |
| if (--data->num_to_report == 0) { | |
| sess->generation++; | |
| GST_DEBUG ("all reported, generation now %u", sess->generation); | |
| } | |
| } | |
| } | |
| static void | |
| schedule_remaining_nacks (const gchar * key, RTPSource * source, | |
| ReportData * data) | |
| { | |
| RTPSession *sess = data->sess; | |
| GstClockTime *nack_deadlines; | |
| GstClockTime deadline; | |
| guint n_nacks; | |
| if (!source->send_nack) | |
| return; | |
| /* the scheduling is entirely based on available bandwidth, just take the | |
| * biggest seqnum, which will have the largest deadline to request early | |
| * RTCP. */ | |
| nack_deadlines = rtp_source_get_nack_deadlines (source, &n_nacks); | |
| deadline = nack_deadlines[n_nacks - 1]; | |
| RTP_SESSION_UNLOCK (sess); | |
| rtp_session_send_rtcp_with_deadline (sess, deadline); | |
| RTP_SESSION_LOCK (sess); | |
| } | |
| static gboolean | |
| rtp_session_are_all_sources_bye (RTPSession * sess) | |
| { | |
| GHashTableIter iter; | |
| RTPSource *src; | |
| RTP_SESSION_LOCK (sess); | |
| g_hash_table_iter_init (&iter, sess->ssrcs[sess->mask_idx]); | |
| while (g_hash_table_iter_next (&iter, NULL, (gpointer *) & src)) { | |
| if (src->internal && !src->sent_bye) { | |
| RTP_SESSION_UNLOCK (sess); | |
| return FALSE; | |
| } | |
| } | |
| RTP_SESSION_UNLOCK (sess); | |
| return TRUE; | |
| } | |
| /** | |
| * rtp_session_on_timeout: | |
| * @sess: an #RTPSession | |
| * @current_time: the current system time | |
| * @ntpnstime: the current NTP time in nanoseconds | |
| * @running_time: the current running_time of the pipeline | |
| * | |
| * Perform maintenance actions after the timeout obtained with | |
| * rtp_session_next_timeout() expired. | |
| * | |
| * This function will perform timeouts of receivers and senders, send a BYE | |
| * packet or generate RTCP packets with current session stats. | |
| * | |
| * This function can call the #RTPSessionSendRTCP callback, possibly multiple | |
| * times, for each packet that should be processed. | |
| * | |
| * Returns: a #GstFlowReturn. | |
| */ | |
| GstFlowReturn | |
| rtp_session_on_timeout (RTPSession * sess, GstClockTime current_time, | |
| guint64 ntpnstime, GstClockTime running_time) | |
| { | |
| GstFlowReturn result = GST_FLOW_OK; | |
| ReportData data = { GST_RTCP_BUFFER_INIT }; | |
| GHashTable *table_copy; | |
| ReportOutput *output; | |
| gboolean all_empty = FALSE; | |
| g_return_val_if_fail (RTP_IS_SESSION (sess), GST_FLOW_ERROR); | |
| GST_DEBUG ("reporting at %" GST_TIME_FORMAT ", NTP time %" GST_TIME_FORMAT | |
| ", running-time %" GST_TIME_FORMAT, GST_TIME_ARGS (current_time), | |
| GST_TIME_ARGS (ntpnstime), GST_TIME_ARGS (running_time)); | |
| data.sess = sess; | |
| data.current_time = current_time; | |
| data.ntpnstime = ntpnstime; | |
| data.running_time = running_time; | |
| data.num_to_report = 0; | |
| data.nacked_seqnums = 0; | |
| data.timeout_inactive_sources = sess->timeout_inactive_sources; | |
| g_queue_init (&data.output); | |
| RTP_SESSION_LOCK (sess); | |
| /* get a new interval, we need this for various cleanups etc */ | |
| data.interval = calculate_rtcp_interval (sess, TRUE, sess->first_rtcp); | |
| GST_DEBUG ("interval %" GST_TIME_FORMAT, GST_TIME_ARGS (data.interval)); | |
| /* we need an internal source now */ | |
| if (sess->stats.internal_sources == 0) { | |
| RTPSource *source; | |
| gboolean created; | |
| source = obtain_internal_source (sess, sess->suggested_ssrc, &created, | |
| current_time); | |
| sess->internal_ssrc_set = TRUE; | |
| if (created) | |
| on_new_sender_ssrc (sess, source); | |
| g_object_unref (source); | |
| } | |
| sess->conflicting_addresses = | |
| timeout_conflicting_addresses (sess->conflicting_addresses, current_time); | |
| /* Make a local copy of the hashtable. We need to do this because the | |
| * cleanup stage below releases the session lock. */ | |
| table_copy = g_hash_table_new_full (NULL, NULL, NULL, | |
| (GDestroyNotify) g_object_unref); | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) clone_ssrcs_hashtable, table_copy); | |
| /* Clean up the session, mark the source for removing, this might release the | |
| * session lock. */ | |
| g_hash_table_foreach (table_copy, (GHFunc) session_cleanup, &data); | |
| g_hash_table_destroy (table_copy); | |
| /* Now remove the marked sources */ | |
| g_hash_table_foreach_remove (sess->ssrcs[sess->mask_idx], | |
| (GHRFunc) remove_closing_sources, &data); | |
| /* update point-to-point status */ | |
| session_update_ptp (sess); | |
| /* see if we need to generate SR or RR packets */ | |
| if (!is_rtcp_time (sess, current_time, &data)) | |
| goto done; | |
| /* check if all the buffers are empty after generation */ | |
| all_empty = TRUE; | |
| /* Make a local copy of the hashtable. We need to do this because the | |
| * generate_rtcp stage below releases the session lock. */ | |
| table_copy = g_hash_table_new_full (NULL, NULL, NULL, | |
| (GDestroyNotify) g_object_unref); | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) clone_ssrcs_hashtable, table_copy); | |
| GST_DEBUG | |
| ("doing RTCP generation %u for %u sources, early %d", | |
| sess->generation, data.num_to_report, data.is_early); | |
| /* generate RTCP for all internal sources, this might release the | |
| * session lock. */ | |
| g_hash_table_foreach (table_copy, (GHFunc) generate_rtcp, &data); | |
| g_hash_table_foreach (table_copy, (GHFunc) generate_twcc, &data); | |
| /* update the generation for all the sources that have been reported */ | |
| g_hash_table_foreach (table_copy, (GHFunc) update_generation, &data); | |
| g_hash_table_destroy (table_copy); | |
| /* we keep track of the last report time in order to timeout inactive | |
| * receivers or senders */ | |
| if (!data.is_early) { | |
| GST_DEBUG ("Time since last regular RTCP: %" GST_TIME_FORMAT " - %" | |
| GST_TIME_FORMAT " = %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (data.current_time), | |
| GST_TIME_ARGS (sess->last_rtcp_send_time), | |
| GST_TIME_ARGS (data.current_time - sess->last_rtcp_send_time)); | |
| sess->last_rtcp_send_time = data.current_time; | |
| } | |
| GST_DEBUG ("Time since last RTCP: %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT | |
| " = %" GST_TIME_FORMAT, GST_TIME_ARGS (data.current_time), | |
| GST_TIME_ARGS (sess->last_rtcp_check_time), | |
| GST_TIME_ARGS (data.current_time - sess->last_rtcp_check_time)); | |
| sess->last_rtcp_check_time = data.current_time; | |
| sess->first_rtcp = FALSE; | |
| sess->next_early_rtcp_time = GST_CLOCK_TIME_NONE; | |
| sess->scheduled_bye = FALSE; | |
| done: | |
| RTP_SESSION_UNLOCK (sess); | |
| /* notify about updated statistics */ | |
| g_object_notify_by_pspec (G_OBJECT (sess), properties[PROP_STATS]); | |
| /* push out the RTCP packets */ | |
| while ((output = g_queue_pop_head (&data.output))) { | |
| gboolean do_not_suppress, empty_buffer; | |
| GstBuffer *buffer = output->buffer; | |
| RTPSource *source = output->source; | |
| /* Give the user a change to add its own packet */ | |
| g_signal_emit (sess, rtp_session_signals[SIGNAL_ON_SENDING_RTCP], 0, | |
| buffer, data.is_early, &do_not_suppress); | |
| /* do_not_suppress is ignored because we never ever suppress RTCP packets | |
| * here. Suppression of regular RTCP happens by simply not scheduling this | |
| * function unless needed */ | |
| empty_buffer = gst_buffer_get_size (buffer) == 0; | |
| if (!empty_buffer) | |
| all_empty = FALSE; | |
| if (sess->callbacks.send_rtcp && !empty_buffer) { | |
| guint packet_size; | |
| packet_size = gst_buffer_get_size (buffer) + sess->header_len; | |
| UPDATE_AVG (sess->stats.avg_rtcp_packet_size, packet_size); | |
| GST_DEBUG ("%p, sending RTCP packet, avg size %u, %u", &sess->stats, | |
| sess->stats.avg_rtcp_packet_size, packet_size); | |
| result = | |
| sess->callbacks.send_rtcp (sess, source, buffer, | |
| rtp_session_are_all_sources_bye (sess), sess->send_rtcp_user_data); | |
| RTP_SESSION_LOCK (sess); | |
| sess->stats.nacks_sent += data.nacked_seqnums; | |
| on_sender_ssrc_active (sess, source); | |
| RTP_SESSION_UNLOCK (sess); | |
| } else { | |
| GST_DEBUG ("freeing packet callback: %p" | |
| " empty_buffer: %d", sess->callbacks.send_rtcp, empty_buffer); | |
| if (!empty_buffer) { | |
| RTP_SESSION_LOCK (sess); | |
| sess->stats.nacks_dropped += data.nacked_seqnums; | |
| RTP_SESSION_UNLOCK (sess); | |
| } | |
| gst_buffer_unref (buffer); | |
| } | |
| g_object_unref (source); | |
| g_free (output); | |
| } | |
| if (all_empty) | |
| GST_ERROR ("generated empty RTCP messages for all the sources"); | |
| /* schedule remaining nacks */ | |
| RTP_SESSION_LOCK (sess); | |
| g_hash_table_foreach (sess->ssrcs[sess->mask_idx], | |
| (GHFunc) schedule_remaining_nacks, &data); | |
| RTP_SESSION_UNLOCK (sess); | |
| return result; | |
| } | |
| /** | |
| * rtp_session_request_early_rtcp: | |
| * @sess: an #RTPSession | |
| * @current_time: the current system time | |
| * @max_delay: maximum delay | |
| * | |
| * Request transmission of early RTCP | |
| * | |
| * Returns: %TRUE if the related RTCP can be scheduled. | |
| */ | |
| gboolean | |
| rtp_session_request_early_rtcp (RTPSession * sess, GstClockTime current_time, | |
| GstClockTime max_delay) | |
| { | |
| GstClockTime T_dither_max, T_rr, offset = 0; | |
| gboolean ret; | |
| gboolean allow_early; | |
| /* Implements the algorithm described in RFC 4585 section 3.5.2 */ | |
| RTP_SESSION_LOCK (sess); | |
| /* We assume a feedback profile if something is requesting RTCP | |
| * to be sent */ | |
| sess->rtp_profile = GST_RTP_PROFILE_AVPF; | |
| /* Check if already requested */ | |
| /* RFC 4585 section 3.5.2 step 2 */ | |
| if (GST_CLOCK_TIME_IS_VALID (sess->next_early_rtcp_time)) { | |
| GST_LOG_OBJECT (sess, "already have next early rtcp time"); | |
| ret = (current_time + max_delay > sess->next_early_rtcp_time); | |
| goto end; | |
| } | |
| if (!GST_CLOCK_TIME_IS_VALID (sess->next_rtcp_check_time)) { | |
| GST_LOG_OBJECT (sess, "no next RTCP check time"); | |
| ret = FALSE; | |
| goto end; | |
| } | |
| /* RFC 4585 section 3.5.3 step 1 | |
| * If no regular RTCP packet has been sent before, then a regular | |
| * RTCP packet has to be scheduled first and FB messages might be | |
| * included there | |
| */ | |
| if (!GST_CLOCK_TIME_IS_VALID (sess->last_rtcp_send_time)) { | |
| GST_LOG_OBJECT (sess, "no RTCP sent yet"); | |
| if (current_time + max_delay > sess->next_rtcp_check_time) { | |
| GST_LOG_OBJECT (sess, | |
| "next scheduled time is soon %" GST_TIME_FORMAT " + %" GST_TIME_FORMAT | |
| " > %" GST_TIME_FORMAT, GST_TIME_ARGS (current_time), | |
| GST_TIME_ARGS (max_delay), | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| ret = TRUE; | |
| } else { | |
| GST_LOG_OBJECT (sess, | |
| "can't allow early feedback, next scheduled time is too late %" | |
| GST_TIME_FORMAT " + %" GST_TIME_FORMAT " < %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (current_time), GST_TIME_ARGS (max_delay), | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| ret = FALSE; | |
| } | |
| goto end; | |
| } | |
| T_rr = sess->last_rtcp_interval; | |
| /* RFC 4585 section 3.5.2 step 2b */ | |
| /* If the total sources is <=2, then there is only us and one peer */ | |
| /* When there is one auxiliary stream the session can still do point | |
| * to point. | |
| */ | |
| if (sess->is_doing_ptp) { | |
| T_dither_max = 0; | |
| } else { | |
| /* Divide by 2 because l = 0.5 */ | |
| T_dither_max = T_rr; | |
| T_dither_max /= 2; | |
| } | |
| /* RFC 4585 section 3.5.2 step 3 */ | |
| if (current_time + T_dither_max > sess->next_rtcp_check_time) { | |
| GST_LOG_OBJECT (sess, | |
| "don't send because of dither, next scheduled time is too soon %" | |
| GST_TIME_FORMAT " + %" GST_TIME_FORMAT " > %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (current_time), GST_TIME_ARGS (T_dither_max), | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| ret = T_dither_max <= max_delay; | |
| goto end; | |
| } | |
| /* RFC 4585 section 3.5.2 step 4a and | |
| * RFC 4585 section 3.5.2 step 6 */ | |
| allow_early = FALSE; | |
| if (sess->last_rtcp_check_time == sess->last_rtcp_send_time) { | |
| /* Last time we sent a full RTCP packet, we can now immediately | |
| * send an early one as allow_early was reset to TRUE */ | |
| allow_early = TRUE; | |
| } else if (sess->last_rtcp_check_time + T_rr <= current_time + max_delay) { | |
| /* Last packet we sent was an early RTCP packet and more than | |
| * T_rr has passed since then, meaning we would have suppressed | |
| * a regular RTCP packet already and reset allow_early to TRUE */ | |
| allow_early = TRUE; | |
| /* We have to offset a bit as T_rr has not passed yet, but will before | |
| * max_delay */ | |
| if (sess->last_rtcp_check_time + T_rr > current_time) | |
| offset = (sess->last_rtcp_check_time + T_rr) - current_time; | |
| } else { | |
| GST_DEBUG_OBJECT (sess, | |
| "can't allow early RTCP yet: last regular %" GST_TIME_FORMAT ", %" | |
| GST_TIME_FORMAT " + %" GST_TIME_FORMAT " > %" GST_TIME_FORMAT " + %" | |
| GST_TIME_FORMAT, GST_TIME_ARGS (sess->last_rtcp_send_time), | |
| GST_TIME_ARGS (sess->last_rtcp_check_time), GST_TIME_ARGS (T_rr), | |
| GST_TIME_ARGS (current_time), GST_TIME_ARGS (max_delay)); | |
| } | |
| if (!allow_early) { | |
| /* Ignore the request a scheduled packet will be in time anyway */ | |
| if (current_time + max_delay > sess->next_rtcp_check_time) { | |
| GST_LOG_OBJECT (sess, | |
| "next scheduled time is soon %" GST_TIME_FORMAT " + %" GST_TIME_FORMAT | |
| " > %" GST_TIME_FORMAT, GST_TIME_ARGS (current_time), | |
| GST_TIME_ARGS (max_delay), | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| ret = TRUE; | |
| } else { | |
| GST_LOG_OBJECT (sess, | |
| "can't allow early feedback and next scheduled time is too late %" | |
| GST_TIME_FORMAT " + %" GST_TIME_FORMAT " < %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (current_time), GST_TIME_ARGS (max_delay), | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| ret = FALSE; | |
| } | |
| goto end; | |
| } | |
| /* RFC 4585 section 3.5.2 step 4b */ | |
| if (T_dither_max) { | |
| /* Schedule an early transmission later */ | |
| sess->next_early_rtcp_time = g_random_double () * T_dither_max + | |
| current_time + offset; | |
| } else { | |
| /* If no dithering, schedule it for NOW */ | |
| sess->next_early_rtcp_time = current_time + offset; | |
| } | |
| GST_LOG_OBJECT (sess, "next early RTCP time %" GST_TIME_FORMAT | |
| ", next regular RTCP time %" GST_TIME_FORMAT, | |
| GST_TIME_ARGS (sess->next_early_rtcp_time), | |
| GST_TIME_ARGS (sess->next_rtcp_check_time)); | |
| RTP_SESSION_UNLOCK (sess); | |
| /* notify app of need to send packet early | |
| * and therefore of timeout change */ | |
| if (sess->callbacks.reconsider) | |
| sess->callbacks.reconsider (sess, sess->reconsider_user_data); | |
| return TRUE; | |
| end: | |
| RTP_SESSION_UNLOCK (sess); | |
| return ret; | |
| } | |
| static gboolean | |
| rtp_session_send_rtcp_internal (RTPSession * sess, GstClockTime now, | |
| GstClockTime max_delay) | |
| { | |
| /* notify the application that we intend to send early RTCP */ | |
| if (sess->callbacks.notify_early_rtcp) | |
| sess->callbacks.notify_early_rtcp (sess, sess->notify_early_rtcp_user_data); | |
| return rtp_session_request_early_rtcp (sess, now, max_delay); | |
| } | |
| static gboolean | |
| rtp_session_send_rtcp_with_deadline (RTPSession * sess, GstClockTime deadline) | |
| { | |
| GstClockTime now, max_delay; | |
| if (!sess->callbacks.send_rtcp) | |
| return FALSE; | |
| now = sess->callbacks.request_time (sess, sess->request_time_user_data); | |
| if (deadline < now) | |
| return FALSE; | |
| max_delay = deadline - now; | |
| return rtp_session_send_rtcp_internal (sess, now, max_delay); | |
| } | |
| static gboolean | |
| rtp_session_send_rtcp (RTPSession * sess, GstClockTime max_delay) | |
| { | |
| GstClockTime now; | |
| if (!sess->callbacks.send_rtcp) | |
| return FALSE; | |
| now = sess->callbacks.request_time (sess, sess->request_time_user_data); | |
| return rtp_session_send_rtcp_internal (sess, now, max_delay); | |
| } | |
| gboolean | |
| rtp_session_request_key_unit (RTPSession * sess, guint32 ssrc, | |
| gboolean fir, gint count) | |
| { | |
| RTPSource *src; | |
| RTP_SESSION_LOCK (sess); | |
| src = find_source (sess, ssrc); | |
| if (src == NULL) | |
| goto no_source; | |
| if (fir) { | |
| src->send_pli = FALSE; | |
| src->send_fir = TRUE; | |
| if (count == -1 || count != src->last_fir_count) | |
| src->current_send_fir_seqnum++; | |
| src->last_fir_count = count; | |
| } else if (!src->send_fir) { | |
| src->send_pli = TRUE; | |
| } | |
| RTP_SESSION_UNLOCK (sess); | |
| if (!rtp_session_send_rtcp (sess, 5 * GST_SECOND)) { | |
| GST_DEBUG ("FIR/PLI not sent early, sending with next regular RTCP"); | |
| } | |
| return TRUE; | |
| /* ERRORS */ | |
| no_source: | |
| { | |
| RTP_SESSION_UNLOCK (sess); | |
| return FALSE; | |
| } | |
| } | |
| /** | |
| * rtp_session_request_nack: | |
| * @sess: a #RTPSession | |
| * @ssrc: the SSRC | |
| * @seqnum: the missing seqnum | |
| * @max_delay: max delay to request NACK | |
| * | |
| * Request scheduling of a NACK feedback packet for @seqnum in @ssrc. | |
| * | |
| * Returns: %TRUE if the NACK feedback could be scheduled | |
| */ | |
| gboolean | |
| rtp_session_request_nack (RTPSession * sess, guint32 ssrc, guint16 seqnum, | |
| GstClockTime max_delay) | |
| { | |
| RTPSource *source; | |
| GstClockTime now; | |
| if (!sess->callbacks.send_rtcp) | |
| return FALSE; | |
| now = sess->callbacks.request_time (sess, sess->request_time_user_data); | |
| RTP_SESSION_LOCK (sess); | |
| source = find_source (sess, ssrc); | |
| if (source == NULL) | |
| goto no_source; | |
| GST_DEBUG ("request NACK for SSRC %08x, #%u, deadline %" GST_TIME_FORMAT, | |
| ssrc, seqnum, GST_TIME_ARGS (now + max_delay)); | |
| rtp_source_register_nack (source, seqnum, now + max_delay); | |
| RTP_SESSION_UNLOCK (sess); | |
| if (!rtp_session_send_rtcp_internal (sess, now, max_delay)) { | |
| GST_DEBUG ("NACK not sent early, sending with next regular RTCP"); | |
| } | |
| return TRUE; | |
| /* ERRORS */ | |
| no_source: | |
| { | |
| RTP_SESSION_UNLOCK (sess); | |
| return FALSE; | |
| } | |
| } | |
| /** | |
| * rtp_session_update_recv_caps_structure: | |
| * @sess: an #RTPSession | |
| * @s: a #GstStructure from a #GstCaps | |
| * | |
| * Update the caps of the receiver in the rtp session. | |
| */ | |
| void | |
| rtp_session_update_recv_caps_structure (RTPSession * sess, | |
| const GstStructure * s) | |
| { | |
| rtp_twcc_manager_parse_recv_ext_id (sess->twcc, s); | |
| } |