mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-26 19:51:11 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-rtsp-server/gst/rtsp-server/rtsp-server-internal.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

73 lines
3.4 KiB
C
Raw Normal View History

stream: refactor TCP backpressure handling The previous implementation stopped sending TCP messages to all clients when a single one stopped consuming them, which obviously created problems for shared media. Instead, we now manage a backlog in stream-transport, and slow clients are removed once this backlog exceeds a maximum duration, currently hardcoded. Fixes #80
2019-10-15 17:08:32 +00:00
/* GStreamer
* Copyright (C) 2019 Mathieu Duponchelle <mathieu@centricular.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.
*/
#ifndef __GST_RTSP_SERVER_INTERNAL_H__
#define __GST_RTSP_SERVER_INTERNAL_H__
#include <glib.h>
G_BEGIN_DECLS
#include "rtsp-stream-transport.h"
/* Internal GstRTSPStreamTransport interface */
typedef gboolean (*GstRTSPBackPressureFunc) (guint8 channel, gpointer user_data);
gboolean gst_rtsp_stream_transport_backlog_push (GstRTSPStreamTransport *trans,
GstBuffer *buffer,
GstBufferList *buffer_list,
gboolean is_rtp);
gboolean gst_rtsp_stream_transport_backlog_pop (GstRTSPStreamTransport *trans,
GstBuffer **buffer,
GstBufferList **buffer_list,
gboolean *is_rtp);
gst-rtsp-server: Fix pushing backlog to client Check back pressure of a stream transport before popping buffer from its backlog. If the stream transport is not experiencing back pressure, the buffer can be popped from backlog and pushed to client. Fixes:#1298 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/2936>
2022-08-24 11:50:19 +00:00
gboolean gst_rtsp_stream_transport_backlog_peek_is_rtp (GstRTSPStreamTransport * trans);
stream: refactor TCP backpressure handling The previous implementation stopped sending TCP messages to all clients when a single one stopped consuming them, which obviously created problems for shared media. Instead, we now manage a backlog in stream-transport, and slow clients are removed once this backlog exceeds a maximum duration, currently hardcoded. Fixes #80
2019-10-15 17:08:32 +00:00
gboolean gst_rtsp_stream_transport_backlog_is_empty (GstRTSPStreamTransport *trans);
rtsp-stream: clear backlog when removing transport This ensures we don't end up calling any of transports' callbacks with a potentially unreffed user_data (in practice, a client that may have been removed)
2020-02-14 13:59:25 +00:00
void gst_rtsp_stream_transport_clear_backlog (GstRTSPStreamTransport * trans);
rtsp-stream: properly protect TCP backlog access Fixes #97 We cannot hold stream->lock while pushing data, but need to consistently check the state of the backlog both from the send_tcp_message function and the on_message_sent function, which may or may not be called from the same thread. This commit introduces internal API to allow for potentially recursive locking of transport streams, addressing a race condition where the RTSP stream could push items out of order when popping them from the backlog.
2020-02-05 19:28:19 +00:00
void gst_rtsp_stream_transport_lock_backlog (GstRTSPStreamTransport * trans);
void gst_rtsp_stream_transport_unlock_backlog (GstRTSPStreamTransport * trans);
stream: refactor TCP backpressure handling The previous implementation stopped sending TCP messages to all clients when a single one stopped consuming them, which obviously created problems for shared media. Instead, we now manage a backlog in stream-transport, and slow clients are removed once this backlog exceeds a maximum duration, currently hardcoded. Fixes #80
2019-10-15 17:08:32 +00:00
void gst_rtsp_stream_transport_set_back_pressure_callback (GstRTSPStreamTransport *trans,
GstRTSPBackPressureFunc back_pressure_func,
gpointer user_data,
GDestroyNotify notify);
gboolean gst_rtsp_stream_transport_check_back_pressure (GstRTSPStreamTransport *trans,
rtsp-stream: fix checking of TCP backpressure The internal index of our appsinks, while it can be used to determine whether a message is RTP or RTCP, is not necessarily the same as the interleaved channel. Let the stream-transport determine the channel to check backpressure for, the same way it determines the channel according to whether it is sending RTP or RTCP.
2020-01-09 13:10:44 +00:00
gboolean is_rtp);
stream: refactor TCP backpressure handling The previous implementation stopped sending TCP messages to all clients when a single one stopped consuming them, which obviously created problems for shared media. Instead, we now manage a backlog in stream-transport, and slow clients are removed once this backlog exceeds a maximum duration, currently hardcoded. Fixes #80
2019-10-15 17:08:32 +00:00
rtsp-media: set a 0 storage size for TCP receivers ulpfec correction is obviously useless when receiving a stream over TCP, and in TCP modes the rtp storage receives non timestamped buffers, causing it to queue buffers indefinitely, until the queue grows so large that sanity checks kick in and warnings start to get emitted. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-rtsp-server/-/merge_requests/149>
2020-09-04 22:30:42 +00:00
gboolean gst_rtsp_stream_is_tcp_receiver (GstRTSPStream * stream);
rtsp-media-factory: expose API to disable RTCP This is supported by the RFC, and can be useful on systems where allocating two consecutive ports is problematic, and RTCP is not necessary. Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-rtsp-server/-/merge_requests/159>
2020-09-04 19:14:35 +00:00
void gst_rtsp_media_set_enable_rtcp (GstRTSPMedia *media, gboolean enable);
void gst_rtsp_stream_set_enable_rtcp (GstRTSPStream *stream, gboolean enable);
rtsp-server: Add new ensure-keyunit-on-start property While the suspend modes NONE and PAUSED provided a low startup latency for connecting clients they did not ensure that streams started on fresh data. With this property we can maintain the low startup latency of those suspend modes while also ensuring that a stream starts on a key unit. Furthermore, by modifying the value of a new property, ensure-keyunit-on-start-timeout, it is possible to accept a keyunit of a certain age but discard it if too much time has passed and instead force a new keyunit. Fixes #2443 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/4334>
2023-06-26 06:25:36 +00:00
void gst_rtsp_stream_set_drop_delta_units (GstRTSPStream * stream, gboolean drop);
gboolean gst_rtsp_stream_install_drop_probe (GstRTSPStream * stream);
stream: refactor TCP backpressure handling The previous implementation stopped sending TCP messages to all clients when a single one stopped consuming them, which obviously created problems for shared media. Instead, we now manage a backlog in stream-transport, and slow clients are removed once this backlog exceeds a maximum duration, currently hardcoded. Fixes #80
2019-10-15 17:08:32 +00:00
G_END_DECLS
#endif /* __GST_RTSP_SERVER_INTERNAL_H__ */
Reference in a new issue Copy permalink