mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-22 16:26:39 +00:00
63108730a5
Adds a new property in multifdsink, resend-streamheader. If this property is false, the multifdsink will not send the streamheader if there's already one set for a particular client. There are some formats in which every stream needs to start with a certain blob, but you can't inject this blob at leisure. If the producer wants to change the blob in question and sets in as the streamheader on the outgoing buffers' caps, new clients of multifdsink will get the new streamheader, but old clients will break, because they'll see the blob in the middle of the stream. The property is true by default, so existing code will not see any difference. Fixes #578118.
286 lines
9.9 KiB
C
286 lines
9.9 KiB
C
/* GStreamer
|
|
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
|
|
* Copyright (C) <2004> Thomas Vander Stichele <thomas at apestaart dot org>
|
|
*
|
|
* 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., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
|
|
#ifndef __GST_MULTI_FD_SINK_H__
|
|
#define __GST_MULTI_FD_SINK_H__
|
|
|
|
#include <gst/gst.h>
|
|
#include <gst/base/gstbasesink.h>
|
|
|
|
G_BEGIN_DECLS
|
|
|
|
#include "gsttcp.h"
|
|
|
|
#define GST_TYPE_MULTI_FD_SINK \
|
|
(gst_multi_fd_sink_get_type())
|
|
#define GST_MULTI_FD_SINK(obj) \
|
|
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULTI_FD_SINK,GstMultiFdSink))
|
|
#define GST_MULTI_FD_SINK_CLASS(klass) \
|
|
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULTI_FD_SINK,GstMultiFdSinkClass))
|
|
#define GST_IS_MULTI_FD_SINK(obj) \
|
|
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULTI_FD_SINK))
|
|
#define GST_IS_MULTI_FD_SINK_CLASS(klass) \
|
|
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULTI_FD_SINK))
|
|
#define GST_MULTI_FD_SINK_GET_CLASS(klass) \
|
|
(G_TYPE_INSTANCE_GET_CLASS ((klass), GST_TYPE_MULTI_FD_SINK, GstMultiFdSinkClass))
|
|
|
|
|
|
typedef struct _GstMultiFdSink GstMultiFdSink;
|
|
typedef struct _GstMultiFdSinkClass GstMultiFdSinkClass;
|
|
|
|
typedef enum {
|
|
GST_MULTI_FD_SINK_OPEN = (GST_ELEMENT_FLAG_LAST << 0),
|
|
|
|
GST_MULTI_FD_SINK_FLAG_LAST = (GST_ELEMENT_FLAG_LAST << 2)
|
|
} GstMultiFdSinkFlags;
|
|
|
|
/**
|
|
* GstRecoverPolicy:
|
|
* @GST_RECOVER_POLICY_NONE : no recovering is done
|
|
* @GST_RECOVER_POLICY_RESYNC_LATEST : client is moved to last buffer
|
|
* @GST_RECOVER_POLICY_RESYNC_SOFT_LIMIT: client is moved to the soft limit
|
|
* @GST_RECOVER_POLICY_RESYNC_KEYFRAME : client is moved to latest keyframe
|
|
*
|
|
* Possible values for the recovery procedure to use when a client consumes
|
|
* data too slow and has a backlag of more that soft-limit buffers.
|
|
*/
|
|
typedef enum
|
|
{
|
|
GST_RECOVER_POLICY_NONE,
|
|
GST_RECOVER_POLICY_RESYNC_LATEST,
|
|
GST_RECOVER_POLICY_RESYNC_SOFT_LIMIT,
|
|
GST_RECOVER_POLICY_RESYNC_KEYFRAME
|
|
} GstRecoverPolicy;
|
|
|
|
/**
|
|
* GstSyncMethod:
|
|
* @GST_SYNC_METHOD_LATEST : client receives most recent buffer
|
|
* @GST_SYNC_METHOD_NEXT_KEYFRAME : client receives next keyframe
|
|
* @GST_SYNC_METHOD_LATEST_KEYFRAME : client receives latest keyframe (burst)
|
|
* @GST_SYNC_METHOD_BURST : client receives specific amount of data
|
|
* @GST_SYNC_METHOD_BURST_KEYFRAME : client receives specific amount of data
|
|
* starting from latest keyframe
|
|
* @GST_SYNC_METHOD_BURST_WITH_KEYFRAME : client receives specific amount of data from
|
|
* a keyframe, or if there is not enough data after
|
|
* the keyframe, starting before the keyframe
|
|
*
|
|
* This enum defines the selection of the first buffer that is sent
|
|
* to a new client.
|
|
*/
|
|
typedef enum
|
|
{
|
|
GST_SYNC_METHOD_LATEST,
|
|
GST_SYNC_METHOD_NEXT_KEYFRAME,
|
|
GST_SYNC_METHOD_LATEST_KEYFRAME,
|
|
GST_SYNC_METHOD_BURST,
|
|
GST_SYNC_METHOD_BURST_KEYFRAME,
|
|
GST_SYNC_METHOD_BURST_WITH_KEYFRAME
|
|
} GstSyncMethod;
|
|
|
|
/**
|
|
* GstTCPUnitType:
|
|
* @GST_TCP_UNIT_TYPE_UNDEFINED: undefined
|
|
* @GST_TCP_UNIT_TYPE_BUFFERS : buffers
|
|
* @GST_TCP_UNIT_TYPE_TIME : timeunits (in nanoseconds)
|
|
* @GST_TCP_UNIT_TYPE_BYTES : bytes
|
|
*
|
|
* The units used to specify limits.
|
|
*/
|
|
typedef enum
|
|
{
|
|
GST_TCP_UNIT_TYPE_UNDEFINED,
|
|
GST_TCP_UNIT_TYPE_BUFFERS,
|
|
GST_TCP_UNIT_TYPE_TIME,
|
|
GST_TCP_UNIT_TYPE_BYTES
|
|
} GstTCPUnitType;
|
|
|
|
/**
|
|
* GstClientStatus:
|
|
* @GST_CLIENT_STATUS_OK : client is ok
|
|
* @GST_CLIENT_STATUS_CLOSED : client closed the socket
|
|
* @GST_CLIENT_STATUS_REMOVED : client is removed
|
|
* @GST_CLIENT_STATUS_SLOW : client is too slow
|
|
* @GST_CLIENT_STATUS_ERROR : client is in error
|
|
* @GST_CLIENT_STATUS_DUPLICATE: same client added twice
|
|
* @GST_CLIENT_STATUS_FLUSHING : client is flushing out the remaining buffers.
|
|
*
|
|
* This specifies the reason why a client was removed from
|
|
* multifdsink and is received in the "client-removed" signal.
|
|
*/
|
|
typedef enum
|
|
{
|
|
GST_CLIENT_STATUS_OK = 0,
|
|
GST_CLIENT_STATUS_CLOSED = 1,
|
|
GST_CLIENT_STATUS_REMOVED = 2,
|
|
GST_CLIENT_STATUS_SLOW = 3,
|
|
GST_CLIENT_STATUS_ERROR = 4,
|
|
GST_CLIENT_STATUS_DUPLICATE = 5,
|
|
GST_CLIENT_STATUS_FLUSHING = 6
|
|
} GstClientStatus;
|
|
|
|
/* structure for a client
|
|
*/
|
|
typedef struct {
|
|
GstPollFD fd;
|
|
|
|
gint bufpos; /* position of this client in the global queue */
|
|
gint flushcount; /* the remaining number of buffers to flush out or -1 if the
|
|
client is not flushing. */
|
|
|
|
GstClientStatus status;
|
|
gboolean is_socket;
|
|
|
|
GSList *sending; /* the buffers we need to send */
|
|
gint bufoffset; /* offset in the first buffer */
|
|
|
|
gboolean discont;
|
|
|
|
GstTCPProtocol protocol;
|
|
|
|
gboolean caps_sent;
|
|
gboolean new_connection;
|
|
|
|
gboolean currently_removing;
|
|
|
|
/* method to sync client when connecting */
|
|
GstSyncMethod sync_method;
|
|
GstTCPUnitType burst_min_unit;
|
|
guint64 burst_min_value;
|
|
GstTCPUnitType burst_max_unit;
|
|
guint64 burst_max_value;
|
|
|
|
GstCaps *caps; /* caps of last queued buffer */
|
|
|
|
/* stats */
|
|
guint64 bytes_sent;
|
|
guint64 connect_time;
|
|
guint64 disconnect_time;
|
|
guint64 last_activity_time;
|
|
guint64 dropped_buffers;
|
|
guint64 avg_queue_size;
|
|
} GstTCPClient;
|
|
|
|
#define CLIENTS_LOCK_INIT(fdsink) (g_static_rec_mutex_init(&fdsink->clientslock))
|
|
#define CLIENTS_LOCK_FREE(fdsink) (g_static_rec_mutex_free(&fdsink->clientslock))
|
|
#define CLIENTS_LOCK(fdsink) (g_static_rec_mutex_lock(&fdsink->clientslock))
|
|
#define CLIENTS_UNLOCK(fdsink) (g_static_rec_mutex_unlock(&fdsink->clientslock))
|
|
|
|
/**
|
|
* GstMultiFdSink:
|
|
*
|
|
* The multifdsink object structure.
|
|
*/
|
|
struct _GstMultiFdSink {
|
|
GstBaseSink element;
|
|
|
|
/*< private >*/
|
|
guint64 bytes_to_serve; /* how much bytes we must serve */
|
|
guint64 bytes_served; /* how much bytes have we served */
|
|
|
|
GStaticRecMutex clientslock; /* lock to protect the clients list */
|
|
GList *clients; /* list of clients we are serving */
|
|
GHashTable *fd_hash; /* index on fd to client */
|
|
guint clients_cookie; /* Cookie to detect changes to the clients list */
|
|
|
|
gint mode;
|
|
GstPoll *fdset;
|
|
|
|
GSList *streamheader; /* GSList of GstBuffers to use as streamheader */
|
|
gboolean previous_buffer_in_caps;
|
|
|
|
GstTCPProtocol protocol;
|
|
guint mtu;
|
|
gint qos_dscp;
|
|
gboolean handle_read;
|
|
|
|
GArray *bufqueue; /* global queue of buffers */
|
|
|
|
gboolean running; /* the thread state */
|
|
GThread *thread; /* the sender thread */
|
|
|
|
/* these values are used to check if a client is reading fast
|
|
* enough and to control receovery */
|
|
GstTCPUnitType unit_type;/* the type of the units */
|
|
gint64 units_max; /* max units to queue for a client */
|
|
gint64 units_soft_max; /* max units a client can lag before recovery starts */
|
|
GstRecoverPolicy recover_policy;
|
|
GstClockTime timeout; /* max amount of nanoseconds to remain idle */
|
|
|
|
GstSyncMethod def_sync_method; /* what method to use for connecting clients */
|
|
GstTCPUnitType def_burst_unit;
|
|
guint64 def_burst_value;
|
|
|
|
/* these values are used to control the amount of data
|
|
* kept in the queues. It allows clients to perform a burst
|
|
* on connect. */
|
|
gint bytes_min; /* min number of bytes to queue */
|
|
gint64 time_min; /* min time to queue */
|
|
gint buffers_min; /* min number of buffers to queue */
|
|
|
|
gboolean resend_streamheader; /* resend streamheader if it changes */
|
|
|
|
/* stats */
|
|
gint buffers_queued; /* number of queued buffers */
|
|
gint bytes_queued; /* number of queued bytes */
|
|
gint time_queued; /* number of queued time */
|
|
|
|
guint8 header_flags;
|
|
};
|
|
|
|
struct _GstMultiFdSinkClass {
|
|
GstBaseSinkClass parent_class;
|
|
|
|
/* element methods */
|
|
void (*add) (GstMultiFdSink *sink, int fd);
|
|
void (*add_full) (GstMultiFdSink *sink, int fd, GstSyncMethod sync,
|
|
GstTCPUnitType format, guint64 value,
|
|
GstTCPUnitType max_unit, guint64 max_value);
|
|
void (*remove) (GstMultiFdSink *sink, int fd);
|
|
void (*remove_flush) (GstMultiFdSink *sink, int fd);
|
|
void (*clear) (GstMultiFdSink *sink);
|
|
GValueArray* (*get_stats) (GstMultiFdSink *sink, int fd);
|
|
|
|
/* vtable */
|
|
gboolean (*init) (GstMultiFdSink *sink);
|
|
gboolean (*wait) (GstMultiFdSink *sink, GstPoll *set);
|
|
gboolean (*close) (GstMultiFdSink *sink);
|
|
void (*removed) (GstMultiFdSink *sink, int fd);
|
|
|
|
/* signals */
|
|
void (*client_added) (GstElement *element, gint fd);
|
|
void (*client_removed) (GstElement *element, gint fd, GstClientStatus status);
|
|
void (*client_fd_removed) (GstElement *element, gint fd);
|
|
};
|
|
|
|
GType gst_multi_fd_sink_get_type (void);
|
|
|
|
void gst_multi_fd_sink_add (GstMultiFdSink *sink, int fd);
|
|
void gst_multi_fd_sink_add_full (GstMultiFdSink *sink, int fd, GstSyncMethod sync,
|
|
GstTCPUnitType min_unit, guint64 min_value,
|
|
GstTCPUnitType max_unit, guint64 max_value);
|
|
void gst_multi_fd_sink_remove (GstMultiFdSink *sink, int fd);
|
|
void gst_multi_fd_sink_remove_flush (GstMultiFdSink *sink, int fd);
|
|
void gst_multi_fd_sink_clear (GstMultiFdSink *sink);
|
|
GValueArray* gst_multi_fd_sink_get_stats (GstMultiFdSink *sink, int fd);
|
|
|
|
G_END_DECLS
|
|
|
|
#endif /* __GST_MULTI_FD_SINK_H__ */
|