X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Frtsp%2Fgstrtspsrc.c;h=bad09a3985068da459e25263a9651d3535c71e33;hb=49e7cb3455668b5e612ab530968b5b004b38baa2;hp=12587c8f9375e9407d9496c0d47b9276777d72f8;hpb=125e835045ff4070b71b8e631f3f0d2c61335907;p=platform%2Fupstream%2Fgst-plugins-good.git diff --git a/gst/rtsp/gstrtspsrc.c b/gst/rtsp/gstrtspsrc.c index 12587c8..bad09a3 100644 --- a/gst/rtsp/gstrtspsrc.c +++ b/gst/rtsp/gstrtspsrc.c @@ -42,6 +42,7 @@ */ /** * SECTION:element-rtspsrc + * @title: rtspsrc * * Makes a connection to an RTSP server and read the data. * rtspsrc strictly follows RFC 2326 and therefore does not (yet) support @@ -66,13 +67,24 @@ * rtspsrc acts like a live source and will therefore only generate data in the * PLAYING state. * - * - * Example launch line + * If a RTP session times out then the rtspsrc will generate an element message + * named "GstRTSPSrcTimeout". Currently this is only supported for timeouts + * triggered by RTCP. + * + * The message's structure contains three fields: + * + * #GstRTSPSrcTimeoutCause `cause`: the cause of the timeout. + * + * #gint `stream-number`: an internal identifier of the stream that timed out. + * + * #guint `ssrc`: the SSRC of the stream that timed out. + * + * ## Example launch line * |[ * gst-launch-1.0 rtspsrc location=rtsp://some.server/url ! fakesink * ]| Establish a connection to an RTSP server and send the raw RTP packets to a * fakesink. - * + * */ #ifdef HAVE_CONFIG_H @@ -124,6 +136,12 @@ enum SIGNAL_SELECT_STREAM, SIGNAL_NEW_MANAGER, SIGNAL_REQUEST_RTCP_KEY, + SIGNAL_ACCEPT_CERTIFICATE, + SIGNAL_BEFORE_SEND, + SIGNAL_PUSH_BACKCHANNEL_BUFFER, + SIGNAL_GET_PARAMETER, + SIGNAL_GET_PARAMETERS, + SIGNAL_SET_PARAMETER, LAST_SIGNAL }; @@ -172,8 +190,8 @@ enum _GstRtspSrcNtpTimeSource NTP_TIME_SOURCE_CLOCK_TIME }; -#define DEBUG_RTSP(__self,msg) if (__self->debug) gst_rtsp_message_dump (msg) -#define DEBUG_SDP(__self,msg) if (__self->debug) gst_sdp_message_dump (msg) +#define DEBUG_RTSP(__self,msg) gst_rtspsrc_print_rtsp_message (__self, msg) +#define DEBUG_SDP(__self,msg) gst_rtspsrc_print_sdp_message (__self, msg) #define GST_TYPE_RTSP_SRC_NTP_TIME_SOURCE (gst_rtsp_src_ntp_time_source_get_type()) static GType @@ -198,6 +216,32 @@ gst_rtsp_src_ntp_time_source_get_type (void) return ntp_time_source_type; } +enum _GstRtspBackchannel +{ + BACKCHANNEL_NONE, + BACKCHANNEL_ONVIF +}; + +#define GST_TYPE_RTSP_BACKCHANNEL (gst_rtsp_backchannel_get_type()) +static GType +gst_rtsp_backchannel_get_type (void) +{ + static GType backchannel_type = 0; + static const GEnumValue backchannel_values[] = { + {BACKCHANNEL_NONE, "No backchannel", "none"}, + {BACKCHANNEL_ONVIF, "ONVIF audio backchannel", "onvif"}, + {0, NULL, NULL}, + }; + + if (G_UNLIKELY (backchannel_type == 0)) { + backchannel_type = + g_enum_register_static ("GstRTSPBackchannel", backchannel_values); + } + return backchannel_type; +} + +#define BACKCHANNEL_ONVIF_HDR_REQUIRE_VAL "www.onvif.org/ver20/backchannel" + #define DEFAULT_LOCATION NULL #define DEFAULT_PROTOCOLS GST_RTSP_LOWER_TRANS_UDP | GST_RTSP_LOWER_TRANS_UDP_MCAST | GST_RTSP_LOWER_TRANS_TCP #define DEFAULT_DEBUG FALSE @@ -231,9 +275,15 @@ gst_rtsp_src_ntp_time_source_get_type (void) #define DEFAULT_USER_AGENT "GStreamer/" PACKAGE_VERSION #define DEFAULT_MAX_RTCP_RTP_TIME_DIFF 1000 #define DEFAULT_RFC7273_SYNC FALSE -#define DEFAULT_MAX_TS_OFFSET_ADJUSTMENT 0 -#define DEFAULT_MAX_TS_OFFSET 3000000000 +#define DEFAULT_MAX_TS_OFFSET_ADJUSTMENT G_GUINT64_CONSTANT(0) +#define DEFAULT_MAX_TS_OFFSET G_GINT64_CONSTANT(3000000000) #define DEFAULT_VERSION GST_RTSP_VERSION_1_0 +#define DEFAULT_BACKCHANNEL GST_RTSP_BACKCHANNEL_NONE +#define DEFAULT_TEARDOWN_TIMEOUT (100 * GST_MSECOND) + +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION +#define DEFAULT_START_POSITION 0 +#endif enum { @@ -243,6 +293,10 @@ enum PROP_DEBUG, PROP_RETRY, PROP_TIMEOUT, +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + PROP_START_POSITION, + PROP_RESUME_POSITION, +#endif PROP_TCP_TIMEOUT, PROP_LATENCY, PROP_DROP_ON_LATENCY, @@ -277,6 +331,8 @@ enum PROP_MAX_TS_OFFSET_ADJUSTMENT, PROP_MAX_TS_OFFSET, PROP_DEFAULT_VERSION, + PROP_BACKCHANNEL, + PROP_TEARDOWN_TIMEOUT, }; #define GST_TYPE_RTSP_NAT_METHOD (gst_rtsp_nat_method_get_type()) @@ -305,6 +361,14 @@ gst_rtsp_nat_method_get_type (void) "rtsp-status-reason", G_TYPE_STRING, GST_STR_NULL((response_msg)->type_data.response.reason), NULL)); \ } while (0) +typedef struct _ParameterRequest +{ + gint cmd; + gchar *content_type; + GString *body; + GstPromise *promise; +} ParameterRequest; + static void gst_rtspsrc_finalize (GObject * object); static void gst_rtspsrc_set_property (GObject * object, guint prop_id, @@ -352,6 +416,28 @@ static gboolean gst_rtspsrc_push_event (GstRTSPSrc * src, GstEvent * event); static void gst_rtspsrc_connection_flush (GstRTSPSrc * src, gboolean flush); static GstRTSPResult gst_rtsp_conninfo_close (GstRTSPSrc * src, GstRTSPConnInfo * info, gboolean free); +static void +gst_rtspsrc_print_rtsp_message (GstRTSPSrc * src, const GstRTSPMessage * msg); +static void +gst_rtspsrc_print_sdp_message (GstRTSPSrc * src, const GstSDPMessage * msg); + +static GstRTSPResult +gst_rtspsrc_get_parameter (GstRTSPSrc * src, ParameterRequest * req); + +static GstRTSPResult +gst_rtspsrc_set_parameter (GstRTSPSrc * src, ParameterRequest * req); + +static gboolean get_parameter (GstRTSPSrc * src, const gchar * parameter, + const gchar * content_type, GstPromise * promise); + +static gboolean get_parameters (GstRTSPSrc * src, gchar ** parameters, + const gchar * content_type, GstPromise * promise); + +static gboolean set_parameter (GstRTSPSrc * src, const gchar * name, + const gchar * value, const gchar * content_type, GstPromise * promise); + +static GstFlowReturn gst_rtspsrc_push_backchannel_buffer (GstRTSPSrc * src, + guint id, GstSample * sample); typedef struct { @@ -360,16 +446,18 @@ typedef struct } PtMapItem; /* commands we send to out loop to notify it of events */ -#define CMD_OPEN (1 << 0) -#define CMD_PLAY (1 << 1) -#define CMD_PAUSE (1 << 2) -#define CMD_CLOSE (1 << 3) -#define CMD_WAIT (1 << 4) -#define CMD_RECONNECT (1 << 5) -#define CMD_LOOP (1 << 6) +#define CMD_OPEN (1 << 0) +#define CMD_PLAY (1 << 1) +#define CMD_PAUSE (1 << 2) +#define CMD_CLOSE (1 << 3) +#define CMD_WAIT (1 << 4) +#define CMD_RECONNECT (1 << 5) +#define CMD_LOOP (1 << 6) +#define CMD_GET_PARAMETER (1 << 7) +#define CMD_SET_PARAMETER (1 << 8) /* mask for all commands */ -#define CMD_ALL ((CMD_LOOP << 1) - 1) +#define CMD_ALL ((CMD_SET_PARAMETER << 1) - 1) #define GST_ELEMENT_PROGRESS(el, type, code, text) \ G_STMT_START { \ @@ -405,12 +493,42 @@ cmd_to_string (guint cmd) return "RECONNECT"; case CMD_LOOP: return "LOOP"; + case CMD_GET_PARAMETER: + return "GET_PARAMETER"; + case CMD_SET_PARAMETER: + return "SET_PARAMETER"; } return "unknown"; } #endif +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION +static void +gst_rtspsrc_post_error_message (GstRTSPSrc * src, GstRTSPSrcError error_id, + const gchar * error_string) +{ + GstMessage *message; + GstStructure *structure; + gboolean ret = TRUE; + + GST_ERROR_OBJECT (src, "[%d] %s", error_id, error_string); + + structure = gst_structure_new ("streaming_error", + "error_id", G_TYPE_UINT, error_id, + "error_string", G_TYPE_STRING, error_string, NULL); + + message = + gst_message_new_custom (GST_MESSAGE_ERROR, GST_OBJECT (src), structure); + + ret = gst_element_post_message (GST_ELEMENT (src), message); + if (!ret) + GST_ERROR_OBJECT (src, "fail to post error message."); + + return; +} +#endif + static gboolean default_select_stream (GstRTSPSrc * src, guint id, GstCaps * caps) { @@ -432,6 +550,26 @@ select_stream_accum (GSignalInvocationHint * ihint, return myboolean; } +static gboolean +default_before_send (GstRTSPSrc * src, GstRTSPMessage * msg) +{ + GST_DEBUG_OBJECT (src, "default handler"); + return TRUE; +} + +static gboolean +before_send_accum (GSignalInvocationHint * ihint, + GValue * return_accu, const GValue * handler_return, gpointer data) +{ + gboolean myboolean; + + myboolean = g_value_get_boolean (handler_return); + g_value_set_boolean (return_accu, myboolean); + + /* prevent send if FALSE */ + return myboolean; +} + static void gst_rtspsrc_class_init (GstRTSPSrcClass * klass) { @@ -462,8 +600,10 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) g_object_class_install_property (gobject_class, PROP_DEBUG, g_param_spec_boolean ("debug", "Debug", - "Dump request and response messages to stdout", - DEFAULT_DEBUG, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + "Dump request and response messages to stdout" + "(DEPRECATED: Printed all RTSP message to gstreamer log as 'log' level)", + DEFAULT_DEBUG, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_DEPRECATED)); g_object_class_install_property (gobject_class, PROP_RETRY, g_param_spec_uint ("retry", "Retry", @@ -476,7 +616,18 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) "Retry TCP transport after UDP timeout microseconds (0 = disabled)", 0, G_MAXUINT64, DEFAULT_TIMEOUT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); - +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + g_object_class_install_property (gobject_class, PROP_START_POSITION, + g_param_spec_uint64 ("pending-start-position", "set start position", + "Set start position before PLAYING request.", + 0, G_MAXUINT64, DEFAULT_START_POSITION, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (gobject_class, PROP_RESUME_POSITION, + g_param_spec_uint64 ("resume-position", "set resume position", + "Set resume position before PLAYING request after pause.", + 0, G_MAXUINT64, DEFAULT_START_POSITION, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); +#endif g_object_class_install_property (gobject_class, PROP_TCP_TIMEOUT, g_param_spec_uint64 ("tcp-timeout", "TCP Timeout", "Fail after timeout microseconds on TCP connections (0 = disabled)", @@ -599,7 +750,7 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) /** * GstRTSPSrc:port-range: * - * Configure the client port numbers that can be used to recieve RTP and + * Configure the client port numbers that can be used to receive RTP and * RTCP. */ g_object_class_install_property (gobject_class, PROP_PORT_RANGE, @@ -757,6 +908,13 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) "(requires clock and offset to be provided)", DEFAULT_RFC7273_SYNC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * GstRTSPSrc:default-rtsp-version: + * + * The preferred RTSP version to use while negotiating the version with the server. + * + * Since: 1.14 + */ g_object_class_install_property (gobject_class, PROP_DEFAULT_VERSION, g_param_spec_enum ("default-rtsp-version", "The RTSP version to try first", @@ -781,7 +939,7 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) G_PARAM_STATIC_STRINGS)); /** - * GstRtpBin:max-ts-offset: + * GstRTSPSrc:max-ts-offset: * * Used to set an upper limit of how large a time offset may be. This * is used to protect against unrealistic values as a result of either @@ -795,6 +953,35 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** + * GstRTSPSrc:backchannel + * + * Select a type of backchannel to setup with the RTSP server. + * Default value is "none". Allowed values are "none" and "onvif". + * + * Since: 1.14 + */ + g_object_class_install_property (gobject_class, PROP_BACKCHANNEL, + g_param_spec_enum ("backchannel", "Backchannel type", + "The type of backchannel to setup. Default is 'none'.", + GST_TYPE_RTSP_BACKCHANNEL, BACKCHANNEL_NONE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + /** + * GstRtspSrc:teardown-timeout + * + * When transitioning PAUSED-READY, allow up to timeout (in nanoseconds) + * delay in order to send teardown (0 = disabled) + * + * Since: 1.14 + */ + g_object_class_install_property (gobject_class, PROP_TEARDOWN_TIMEOUT, + g_param_spec_uint64 ("teardown-timeout", "Teardown Timeout", + "When transitioning PAUSED-READY, allow up to timeout (in nanoseconds) " + "delay in order to send teardown (0 = disabled)", + 0, G_MAXUINT64, DEFAULT_TEARDOWN_TIMEOUT, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + /** * GstRTSPSrc::handle-request: * @rtspsrc: a #GstRTSPSrc * @request: a #GstRTSPMessage @@ -820,7 +1007,7 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) * @rtspsrc: a #GstRTSPSrc * @sdp: a #GstSDPMessage * - * Emited when the client has retrieved the SDP and before it configures the + * Emitted when the client has retrieved the SDP and before it configures the * streams in the SDP. @sdp can be inspected and modified. * * This signal is called from the streaming thread, you should therefore not @@ -842,7 +1029,7 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) * @num: the stream number * @caps: the stream caps * - * Emited before the client decides to configure the stream @num with + * Emitted before the client decides to configure the stream @num with * @caps. * * Returns: %TRUE when the stream should be selected, %FALSE when the stream @@ -861,7 +1048,7 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) * @rtspsrc: a #GstRTSPSrc * @manager: a #GstElement * - * Emited after a new manager (like rtpbin) was created and the default + * Emitted after a new manager (like rtpbin) was created and the default * properties were configured. * * Since: 1.4 @@ -876,7 +1063,7 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) * @rtspsrc: a #GstRTSPSrc * @num: the stream number * - * Signal emited to get the crypto parameters relevant to the RTCP + * Signal emitted to get the crypto parameters relevant to the RTCP * stream. User should provide the key and the RTCP encryption ciphers * and authentication, and return them wrapped in a GstCaps. * @@ -886,6 +1073,119 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) g_signal_new ("request-rtcp-key", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, GST_TYPE_CAPS, 1, G_TYPE_UINT); + /** + * GstRTSPSrc::accept-certificate: + * @rtspsrc: a #GstRTSPSrc + * @peer_cert: the peer's #GTlsCertificate + * @errors: the problems with @peer_cert + * @user_data: user data set when the signal handler was connected. + * + * This will directly map to #GTlsConnection 's "accept-certificate" + * signal and be performed after the default checks of #GstRTSPConnection + * (checking against the #GTlsDatabase with the given #GTlsCertificateFlags) + * have failed. If no #GTlsDatabase is set on this connection, only this + * signal will be emitted. + * + * Since: 1.14 + */ + gst_rtspsrc_signals[SIGNAL_ACCEPT_CERTIFICATE] = + g_signal_new ("accept-certificate", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, g_signal_accumulator_true_handled, NULL, NULL, + G_TYPE_BOOLEAN, 3, G_TYPE_TLS_CONNECTION, G_TYPE_TLS_CERTIFICATE, + G_TYPE_TLS_CERTIFICATE_FLAGS); + + /* + * GstRTSPSrc::before-send + * @rtspsrc: a #GstRTSPSrc + * @num: the stream number + * + * Emitted before each RTSP request is sent, in order to allow + * the application to modify send parameters or to skip the message entirely. + * This can be used, for example, to work with ONVIF Profile G servers, + * which need a different/additional range, rate-control, and intra/x + * parameters. + * + * Returns: %TRUE when the command should be sent, %FALSE when the + * command should be dropped. + * + * Since: 1.14 + */ + gst_rtspsrc_signals[SIGNAL_BEFORE_SEND] = + g_signal_new_class_handler ("before-send", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_CLEANUP, + (GCallback) default_before_send, before_send_accum, NULL, + g_cclosure_marshal_generic, G_TYPE_BOOLEAN, + 1, GST_TYPE_RTSP_MESSAGE | G_SIGNAL_TYPE_STATIC_SCOPE); + + /** + * GstRTSPSrc::push-backchannel-buffer: + * @rtspsrc: a #GstRTSPSrc + * @buffer: RTP buffer to send back + * + * + */ + gst_rtspsrc_signals[SIGNAL_PUSH_BACKCHANNEL_BUFFER] = + g_signal_new ("push-backchannel-buffer", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRTSPSrcClass, + push_backchannel_buffer), NULL, NULL, NULL, GST_TYPE_FLOW_RETURN, 2, + G_TYPE_UINT, GST_TYPE_BUFFER); + + /** + * GstRTSPSrc::get-parameter: + * @rtspsrc: a #GstRTSPSrc + * @parameter: the parameter name + * @parameter: the content type + * @parameter: a pointer to #GstPromise + * + * Handle the GET_PARAMETER signal. + * + * Returns: %TRUE when the command could be issued, %FALSE otherwise + * + */ + gst_rtspsrc_signals[SIGNAL_GET_PARAMETER] = + g_signal_new ("get-parameter", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRTSPSrcClass, + get_parameter), NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, 3, G_TYPE_STRING, G_TYPE_STRING, GST_TYPE_PROMISE); + + /** + * GstRTSPSrc::get-parameters: + * @rtspsrc: a #GstRTSPSrc + * @parameter: a NULL-terminated array of parameters + * @parameter: the content type + * @parameter: a pointer to #GstPromise + * + * Handle the GET_PARAMETERS signal. + * + * Returns: %TRUE when the command could be issued, %FALSE otherwise + * + */ + gst_rtspsrc_signals[SIGNAL_GET_PARAMETERS] = + g_signal_new ("get-parameters", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRTSPSrcClass, + get_parameters), NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, 3, G_TYPE_STRV, G_TYPE_STRING, GST_TYPE_PROMISE); + + /** + * GstRTSPSrc::set-parameter: + * @rtspsrc: a #GstRTSPSrc + * @parameter: the parameter name + * @parameter: the parameter value + * @parameter: the content type + * @parameter: a pointer to #GstPromise + * + * Handle the SET_PARAMETER signal. + * + * Returns: %TRUE when the command could be issued, %FALSE otherwise + * + */ + gst_rtspsrc_signals[SIGNAL_SET_PARAMETER] = + g_signal_new ("set-parameter", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRTSPSrcClass, + set_parameter), NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, + GST_TYPE_PROMISE); + gstelement_class->send_event = gst_rtspsrc_send_event; gstelement_class->provide_clock = gst_rtspsrc_provide_clock; gstelement_class->change_state = gst_rtspsrc_change_state; @@ -901,9 +1201,142 @@ gst_rtspsrc_class_init (GstRTSPSrcClass * klass) gstbin_class->handle_message = gst_rtspsrc_handle_message; + klass->push_backchannel_buffer = gst_rtspsrc_push_backchannel_buffer; + klass->get_parameter = GST_DEBUG_FUNCPTR (get_parameter); + klass->get_parameters = GST_DEBUG_FUNCPTR (get_parameters); + klass->set_parameter = GST_DEBUG_FUNCPTR (set_parameter); + gst_rtsp_ext_list_init (); } +static gboolean +validate_set_get_parameter_name (const gchar * parameter_name) +{ + gchar *ptr = (gchar *) parameter_name; + + while (*ptr) { + /* Don't allow '\r', '\n', \'t', ' ' etc in the parameter name */ + if (g_ascii_isspace (*ptr) || g_ascii_iscntrl (*ptr)) { + GST_DEBUG ("invalid parameter name '%s'", parameter_name); + return FALSE; + } + ptr++; + } + return TRUE; +} + +static gboolean +validate_set_get_parameters (gchar ** parameter_names) +{ + while (*parameter_names) { + if (!validate_set_get_parameter_name (*parameter_names)) { + return FALSE; + } + parameter_names++; + } + return TRUE; +} + +static gboolean +get_parameter (GstRTSPSrc * src, const gchar * parameter, + const gchar * content_type, GstPromise * promise) +{ + gchar *parameters[] = { (gchar *) parameter, NULL }; + + GST_LOG_OBJECT (src, "get_parameter: %s", GST_STR_NULL (parameter)); + + if (parameter == NULL || parameter[0] == '\0' || promise == NULL) { + GST_DEBUG ("invalid input"); + return FALSE; + } + + return get_parameters (src, parameters, content_type, promise); +} + +static gboolean +get_parameters (GstRTSPSrc * src, gchar ** parameters, + const gchar * content_type, GstPromise * promise) +{ + ParameterRequest *req; + + GST_LOG_OBJECT (src, "get_parameters: %d", g_strv_length (parameters)); + + if (parameters == NULL || promise == NULL) { + GST_DEBUG ("invalid input"); + return FALSE; + } + + if (src->state == GST_RTSP_STATE_INVALID) { + GST_DEBUG ("invalid state"); + return FALSE; + } + + if (!validate_set_get_parameters (parameters)) { + return FALSE; + } + + req = g_new0 (ParameterRequest, 1); + req->promise = gst_promise_ref (promise); + req->cmd = CMD_GET_PARAMETER; + /* Set the request body according to RFC 2326 or RFC 7826 */ + req->body = g_string_new (NULL); + while (*parameters) { + g_string_append_printf (req->body, "%s:\r\n", *parameters); + parameters++; + } + if (content_type) + req->content_type = g_strdup (content_type); + + GST_OBJECT_LOCK (src); + g_queue_push_tail (&src->set_get_param_q, req); + GST_OBJECT_UNLOCK (src); + + gst_rtspsrc_loop_send_cmd (src, CMD_GET_PARAMETER, CMD_LOOP); + + return TRUE; +} + +static gboolean +set_parameter (GstRTSPSrc * src, const gchar * name, const gchar * value, + const gchar * content_type, GstPromise * promise) +{ + ParameterRequest *req; + + GST_LOG_OBJECT (src, "set_parameter: %s: %s", GST_STR_NULL (name), + GST_STR_NULL (value)); + + if (name == NULL || name[0] == '\0' || value == NULL || promise == NULL) { + GST_DEBUG ("invalid input"); + return FALSE; + } + + if (src->state == GST_RTSP_STATE_INVALID) { + GST_DEBUG ("invalid state"); + return FALSE; + } + + if (!validate_set_get_parameter_name (name)) { + return FALSE; + } + + req = g_new0 (ParameterRequest, 1); + req->cmd = CMD_SET_PARAMETER; + req->promise = gst_promise_ref (promise); + req->body = g_string_new (NULL); + /* Set the request body according to RFC 2326 or RFC 7826 */ + g_string_append_printf (req->body, "%s: %s\r\n", name, value); + if (content_type) + req->content_type = g_strdup (content_type); + + GST_OBJECT_LOCK (src); + g_queue_push_tail (&src->set_get_param_q, req); + GST_OBJECT_UNLOCK (src); + + gst_rtspsrc_loop_send_cmd (src, CMD_SET_PARAMETER, CMD_LOOP); + + return TRUE; +} + static void gst_rtspsrc_init (GstRTSPSrc * src) { @@ -912,6 +1345,14 @@ gst_rtspsrc_init (GstRTSPSrc * src) src->debug = DEFAULT_DEBUG; src->retry = DEFAULT_RETRY; src->udp_timeout = DEFAULT_TIMEOUT; +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + src->start_position = DEFAULT_START_POSITION; + src->is_audio_codec_supported = FALSE; + src->is_video_codec_supported = FALSE; + src->audio_codec = NULL; + src->video_codec = NULL; + src->video_frame_size = NULL; +#endif gst_rtspsrc_set_tcp_timeout (src, DEFAULT_TCP_TIMEOUT); src->latency = DEFAULT_LATENCY_MS; src->drop_on_latency = DEFAULT_DROP_ON_LATENCY; @@ -947,7 +1388,12 @@ gst_rtspsrc_init (GstRTSPSrc * src) src->max_ts_offset_is_set = FALSE; src->default_version = DEFAULT_VERSION; src->version = GST_RTSP_VERSION_INVALID; + src->teardown_timeout = DEFAULT_TEARDOWN_TIMEOUT; +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + g_mutex_init (&(src)->pause_lock); + g_cond_init (&(src)->open_end); +#endif /* get a list of all extensions */ src->extensions = gst_rtsp_ext_list_get (); @@ -962,10 +1408,13 @@ gst_rtspsrc_init (GstRTSPSrc * src) /* protects our state changes from multiple invocations */ g_rec_mutex_init (&src->state_rec_lock); + g_queue_init (&src->set_get_param_q); + src->state = GST_RTSP_STATE_INVALID; g_mutex_init (&src->conninfo.send_lock); g_mutex_init (&src->conninfo.recv_lock); + g_cond_init (&src->cmd_cond); GST_OBJECT_FLAG_SET (src, GST_ELEMENT_FLAG_SOURCE); gst_bin_set_suppressed_flags (GST_BIN (src), @@ -973,12 +1422,47 @@ gst_rtspsrc_init (GstRTSPSrc * src) } static void +free_param_data (ParameterRequest * req) +{ + gst_promise_unref (req->promise); + if (req->body) + g_string_free (req->body, TRUE); + g_free (req->content_type); + g_free (req); +} + +static void +free_param_queue (gpointer data) +{ + ParameterRequest *req = data; + + gst_promise_expire (req->promise); + free_param_data (req); +} + +static void gst_rtspsrc_finalize (GObject * object) { GstRTSPSrc *rtspsrc; rtspsrc = GST_RTSPSRC (object); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + rtspsrc->is_audio_codec_supported = FALSE; + rtspsrc->is_video_codec_supported = FALSE; + if (rtspsrc->audio_codec) { + g_free (rtspsrc->audio_codec); + rtspsrc->audio_codec = NULL; + } + if (rtspsrc->video_codec) { + g_free (rtspsrc->video_codec); + rtspsrc->video_codec = NULL; + } + if (rtspsrc->video_frame_size) { + g_free (rtspsrc->video_frame_size); + rtspsrc->video_frame_size = NULL; + } +#endif gst_rtsp_ext_list_free (rtspsrc->extensions); g_free (rtspsrc->conninfo.location); gst_rtsp_url_free (rtspsrc->conninfo.url); @@ -988,6 +1472,11 @@ gst_rtspsrc_finalize (GObject * object) g_free (rtspsrc->multi_iface); g_free (rtspsrc->user_agent); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + g_mutex_clear (&(rtspsrc)->pause_lock); + g_cond_clear (&(rtspsrc)->open_end); +#endif + if (rtspsrc->sdp) { gst_sdp_message_free (rtspsrc->sdp); rtspsrc->sdp = NULL; @@ -1010,6 +1499,7 @@ gst_rtspsrc_finalize (GObject * object) g_mutex_clear (&rtspsrc->conninfo.send_lock); g_mutex_clear (&rtspsrc->conninfo.recv_lock); + g_cond_clear (&rtspsrc->cmd_cond); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -1123,6 +1613,16 @@ gst_rtspsrc_set_property (GObject * object, guint prop_id, const GValue * value, case PROP_TIMEOUT: rtspsrc->udp_timeout = g_value_get_uint64 (value); break; +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + case PROP_START_POSITION: + rtspsrc->start_position = g_value_get_uint64 (value); + break; + case PROP_RESUME_POSITION: + rtspsrc->last_pos = g_value_get_uint64 (value); + GST_DEBUG_OBJECT (rtspsrc, "src->last_pos value set to %" GST_TIME_FORMAT, + GST_TIME_ARGS (rtspsrc->last_pos)); + break; +#endif case PROP_TCP_TIMEOUT: gst_rtspsrc_set_tcp_timeout (rtspsrc, g_value_get_uint64 (value)); break; @@ -1174,7 +1674,7 @@ gst_rtspsrc_set_property (GObject * object, guint prop_id, const GValue * value, const gchar *str; str = g_value_get_string (value); - if (sscanf (str, "%u-%u", &rtspsrc->client_port_range.min, + if (str == NULL || sscanf (str, "%u-%u", &rtspsrc->client_port_range.min, &rtspsrc->client_port_range.max) != 2) { rtspsrc->client_port_range.min = 0; rtspsrc->client_port_range.max = 0; @@ -1256,6 +1756,12 @@ gst_rtspsrc_set_property (GObject * object, guint prop_id, const GValue * value, case PROP_DEFAULT_VERSION: rtspsrc->default_version = g_value_get_enum (value); break; + case PROP_BACKCHANNEL: + rtspsrc->backchannel = g_value_get_enum (value); + break; + case PROP_TEARDOWN_TIMEOUT: + rtspsrc->teardown_timeout = g_value_get_uint64 (value); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -1286,6 +1792,14 @@ gst_rtspsrc_get_property (GObject * object, guint prop_id, GValue * value, case PROP_TIMEOUT: g_value_set_uint64 (value, rtspsrc->udp_timeout); break; +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + case PROP_START_POSITION: + g_value_set_uint64 (value, rtspsrc->start_position); + break; + case PROP_RESUME_POSITION: + g_value_set_uint64 (value, rtspsrc->last_pos); + break; +#endif case PROP_TCP_TIMEOUT: { guint64 timeout; @@ -1414,6 +1928,12 @@ gst_rtspsrc_get_property (GObject * object, guint prop_id, GValue * value, case PROP_DEFAULT_VERSION: g_value_set_enum (value, rtspsrc->default_version); break; + case PROP_BACKCHANNEL: + g_value_set_enum (value, rtspsrc->backchannel); + break; + case PROP_TEARDOWN_TIMEOUT: + g_value_set_uint64 (value, rtspsrc->teardown_timeout); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -1626,7 +2146,9 @@ gst_rtspsrc_collect_payloads (GstRTSPSrc * src, const GstSDPMessage * sdp, else goto unknown_proto; - if (gst_sdp_media_get_attribute_val (media, "sendonly") != NULL) + if (gst_sdp_media_get_attribute_val (media, "sendonly") != NULL && + /* We want to setup caps for streams configured as backchannel */ + !stream->is_backchannel && src->backchannel != BACKCHANNEL_NONE) goto sendonly_media; /* Parse global SDP attributes once */ @@ -1648,7 +2170,9 @@ gst_rtspsrc_collect_payloads (GstRTSPSrc * src, const GstSDPMessage * sdp, GstStructure *s; const gchar *enc; PtMapItem item; - +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + const gchar *encoder, *mediatype; +#endif pt = atoi (gst_sdp_media_get_format (media, i)); GST_DEBUG_OBJECT (src, " looking at %d pt: %d", i, pt); @@ -1667,6 +2191,51 @@ gst_rtspsrc_collect_payloads (GstRTSPSrc * src, const GstSDPMessage * sdp, if (strcmp (enc, "X-ASF-PF") == 0) stream->container = TRUE; } +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + if ((mediatype = gst_structure_get_string (s, "media"))) { + GST_DEBUG_OBJECT (src, " mediatype : %s", mediatype); + if (!strcmp (mediatype, "video")) { + if ((encoder = gst_structure_get_string (s, "encoding-name"))) { + GST_DEBUG_OBJECT (src, " encoder : %s", encoder); + if ((!strcmp (encoder, "H261")) || + (!strcmp (encoder, "H263")) || + (!strcmp (encoder, "H263-1998")) + || (!strcmp (encoder, "H263-2000")) || (!strcmp (encoder, "H264")) + || (!strcmp (encoder, "MP4V-ES"))) { + src->is_video_codec_supported = TRUE; + GST_DEBUG_OBJECT (src, "Supported Video Codec %s", encoder); + } else { + GST_DEBUG_OBJECT (src, "Unsupported Video Codec %s", encoder); + } + } + + src->video_codec = g_strdup (encoder); + src->video_frame_size = + g_strdup (gst_structure_get_string (s, "a-framesize")); + GST_DEBUG_OBJECT (src, "video_codec %s , video_frame_size %s ", + src->video_codec, src->video_frame_size); + } else if (!strcmp (mediatype, "audio")) { + if ((encoder = gst_structure_get_string (s, "encoding-name"))) { + GST_DEBUG_OBJECT (src, " encoder : %s", encoder); + if ((!strcmp (encoder, "MP4A-LATM")) || + (!strcmp (encoder, "AMR")) || (!strcmp (encoder, "AMR-WB")) + || (!strcmp (encoder, "AMR-NB")) + || (!strcmp (encoder, "mpeg4-generic")) + || (!strcmp (encoder, "MPEG4-GENERIC")) + || (!strcmp (encoder, "QCELP")) || ((strstr (encoder, "G726")) + || (strstr (encoder, "PCMU")))) { + src->is_audio_codec_supported = TRUE; + GST_DEBUG_OBJECT (src, "Supported Audio Codec %s", encoder); + } else { + GST_DEBUG_OBJECT (src, "Unsupported Audio Codec %s", encoder); + } + } + + src->audio_codec = g_strdup (encoder); + GST_DEBUG_OBJECT (src, "audio_codec %s ", src->audio_codec); + } + } +#endif /* Merge in global caps */ /* Intersect will merge in missing fields to the current caps */ @@ -1700,7 +2269,7 @@ unknown_proto: } sendonly_media: { - GST_DEBUG_OBJECT (src, "sendonly media ignored"); + GST_DEBUG_OBJECT (src, "sendonly media ignored, no backchannel"); return; } } @@ -1760,10 +2329,16 @@ gst_rtspsrc_create_stream (GstRTSPSrc * src, GstSDPMessage * sdp, gint idx, stream->ptmap = g_array_new (FALSE, FALSE, sizeof (PtMapItem)); stream->mikey = NULL; stream->stream_id = NULL; + stream->is_backchannel = FALSE; g_mutex_init (&stream->conninfo.send_lock); g_mutex_init (&stream->conninfo.recv_lock); g_array_set_clear_func (stream->ptmap, (GDestroyNotify) clear_ptmap_item); + /* stream is sendonly and onvif backchannel is requested */ + if (gst_sdp_media_get_attribute_val (media, "sendonly") != NULL && + src->backchannel != BACKCHANNEL_NONE) + stream->is_backchannel = TRUE; + /* collect bandwidth information for this steam. FIXME, configure in the RTP * session manager to scale RTCP. */ gst_rtspsrc_collect_bandwidth (src, sdp, media, stream); @@ -1849,7 +2424,9 @@ gst_rtspsrc_stream_free (GstRTSPSrc * src, GstRTSPStream * stream) for (i = 0; i < 2; i++) { if (stream->udpsrc[i]) { gst_element_set_state (stream->udpsrc[i], GST_STATE_NULL); - gst_bin_remove (GST_BIN_CAST (src), stream->udpsrc[i]); + if (gst_object_has_as_parent (GST_OBJECT (stream->udpsrc[i]), + GST_OBJECT (src))) + gst_bin_remove (GST_BIN_CAST (src), stream->udpsrc[i]); gst_object_unref (stream->udpsrc[i]); } if (stream->channelpad[i]) @@ -1857,14 +2434,16 @@ gst_rtspsrc_stream_free (GstRTSPSrc * src, GstRTSPStream * stream) if (stream->udpsink[i]) { gst_element_set_state (stream->udpsink[i], GST_STATE_NULL); - gst_bin_remove (GST_BIN_CAST (src), stream->udpsink[i]); + if (gst_object_has_as_parent (GST_OBJECT (stream->udpsink[i]), + GST_OBJECT (src))) + gst_bin_remove (GST_BIN_CAST (src), stream->udpsink[i]); gst_object_unref (stream->udpsink[i]); } } - if (stream->fakesrc) { - gst_element_set_state (stream->fakesrc, GST_STATE_NULL); - gst_bin_remove (GST_BIN_CAST (src), stream->fakesrc); - gst_object_unref (stream->fakesrc); + if (stream->rtpsrc) { + gst_element_set_state (stream->rtpsrc, GST_STATE_NULL); + gst_bin_remove (GST_BIN_CAST (src), stream->rtpsrc); + gst_object_unref (stream->rtpsrc); } if (stream->srcpad) { gst_pad_set_active (stream->srcpad, FALSE); @@ -1941,6 +2520,11 @@ gst_rtspsrc_cleanup (GstRTSPSrc * src) gst_object_unref (src->provided_clock); src->provided_clock = NULL; } + + /* free parameter requests queue */ + if (!g_queue_is_empty (&src->set_get_param_q)) + g_queue_free_full (&src->set_get_param_q, free_param_queue); + } static gboolean @@ -2126,6 +2710,11 @@ gst_rtspsrc_set_state (GstRTSPSrc * src, GstState state) { GList *walk; +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + GST_WARNING_OBJECT (src, "Setting [%s] element state to: %s \n", + GST_ELEMENT_NAME (GST_ELEMENT_CAST (src)), + gst_element_state_get_name (state)); +#endif if (src->manager) gst_element_set_state (GST_ELEMENT_CAST (src->manager), state); @@ -2141,7 +2730,8 @@ gst_rtspsrc_set_state (GstRTSPSrc * src, GstState state) } static void -gst_rtspsrc_flush (GstRTSPSrc * src, gboolean flush, gboolean playing) +gst_rtspsrc_flush (GstRTSPSrc * src, gboolean flush, gboolean playing, + guint32 seqnum) { GstEvent *event; gint cmd; @@ -2149,11 +2739,13 @@ gst_rtspsrc_flush (GstRTSPSrc * src, gboolean flush, gboolean playing) if (flush) { event = gst_event_new_flush_start (); + gst_event_set_seqnum (event, seqnum); GST_DEBUG_OBJECT (src, "start flush"); cmd = CMD_WAIT; state = GST_STATE_PAUSED; } else { event = gst_event_new_flush_stop (FALSE); + gst_event_set_seqnum (event, seqnum); GST_DEBUG_OBJECT (src, "stop flush; playing %d", playing); cmd = CMD_LOOP; if (playing) @@ -2246,25 +2838,29 @@ gst_rtspsrc_perform_seek (GstRTSPSrc * src, GstEvent * event) GList *walk; const gchar *seek_style = NULL; - if (event) { - GST_DEBUG_OBJECT (src, "doing seek with event"); + GST_DEBUG_OBJECT (src, "doing seek with event %" GST_PTR_FORMAT, event); - gst_event_parse_seek (event, &rate, &format, &flags, - &cur_type, &cur, &stop_type, &stop); + gst_event_parse_seek (event, &rate, &format, &flags, + &cur_type, &cur, &stop_type, &stop); - /* no negative rates yet */ - if (rate < 0.0) - goto negative_rate; + /* no negative rates yet */ + if (rate < 0.0) + goto negative_rate; - /* we need TIME format */ - if (format != src->segment.format) - goto no_format; - } else { - GST_DEBUG_OBJECT (src, "doing seek without event"); - flags = 0; - cur_type = GST_SEEK_TYPE_SET; - stop_type = GST_SEEK_TYPE_SET; - } + /* we need TIME format */ + if (format != src->segment.format) + goto no_format; + + /* Check if we are not at all seekable */ + if (src->seekable == -1.0) + goto not_seekable; + + /* Additional seeking-to-beginning-only check */ + if (src->seekable == 0.0 && cur != 0) + goto not_seekable; + + if (flags & GST_SEEK_FLAG_SEGMENT) + goto invalid_segment_flag; /* get flush flag */ flush = flags & GST_SEEK_FLAG_FLUSH; @@ -2278,7 +2874,7 @@ gst_rtspsrc_perform_seek (GstRTSPSrc * src, GstEvent * event) * blocking in preroll). */ if (flush) { GST_DEBUG_OBJECT (src, "starting flush"); - gst_rtspsrc_flush (src, TRUE, FALSE); + gst_rtspsrc_flush (src, TRUE, FALSE, gst_event_get_seqnum (event)); } else { if (src->task) { gst_task_pause (src->task); @@ -2300,11 +2896,9 @@ gst_rtspsrc_perform_seek (GstRTSPSrc * src, GstEvent * event) /* configure the seek parameters in the seeksegment. We will then have the * right values in the segment to perform the seek */ - if (event) { - GST_DEBUG_OBJECT (src, "configuring seek"); - gst_segment_do_seek (&seeksegment, rate, format, flags, - cur_type, cur, stop_type, stop, &update); - } + GST_DEBUG_OBJECT (src, "configuring seek"); + gst_segment_do_seek (&seeksegment, rate, format, flags, + cur_type, cur, stop_type, stop, &update); /* figure out the last position we need to play. If it's configured (stop != * -1), use that, else we play until the total duration of the file */ @@ -2329,7 +2923,7 @@ gst_rtspsrc_perform_seek (GstRTSPSrc * src, GstEvent * event) if (flush) { /* if we started flush, we stop now */ GST_DEBUG_OBJECT (src, "stopping flush"); - gst_rtspsrc_flush (src, FALSE, playing); + gst_rtspsrc_flush (src, FALSE, playing, gst_event_get_seqnum (event)); } /* now we did the seek and can activate the new segment values */ @@ -2390,6 +2984,16 @@ no_format: GST_DEBUG_OBJECT (src, "unsupported format given, seek aborted."); return FALSE; } +not_seekable: + { + GST_DEBUG_OBJECT (src, "stream is not seekable"); + return FALSE; + } +invalid_segment_flag: + { + GST_WARNING_OBJECT (src, "Segment seeks not supported"); + return FALSE; + } } static gboolean @@ -2451,6 +3055,7 @@ gst_rtspsrc_handle_src_sink_event (GstPad * pad, GstObject * parent, gst_event_unref (event); event = gst_event_new_stream_start (stream_id); + g_free (stream_id); break; } default: @@ -2587,6 +3192,8 @@ gst_rtspsrc_handle_src_query (GstPad * pad, GstObject * parent, } } + GST_LOG_OBJECT (src, "seekable : %d", seekable); + gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, start, duration); res = TRUE; @@ -2668,10 +3275,75 @@ gst_rtspsrc_sink_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) return res; } -static GstPadProbeReturn -pad_blocked (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +static GstFlowReturn +gst_rtspsrc_push_backchannel_buffer (GstRTSPSrc * src, guint id, + GstSample * sample) { - GstRTSPSrc *src = user_data; + GstFlowReturn res = GST_FLOW_OK; + GstRTSPStream *stream; + + if (!src->conninfo.connected || src->state != GST_RTSP_STATE_PLAYING) + goto out; + + stream = find_stream (src, &id, (gpointer) find_stream_by_id); + if (stream == NULL) { + GST_ERROR_OBJECT (src, "no stream with id %u", id); + goto out; + } + + if (src->interleaved) { + GstBuffer *buffer; + GstMapInfo map; + guint8 *data; + guint size; + GstRTSPResult ret; + GstRTSPMessage message = { 0 }; + GstRTSPConnInfo *conninfo; + + buffer = gst_sample_get_buffer (sample); + + gst_buffer_map (buffer, &map, GST_MAP_READ); + size = map.size; + data = map.data; + + gst_rtsp_message_init_data (&message, stream->channel[0]); + + /* lend the body data to the message */ + gst_rtsp_message_take_body (&message, data, size); + + if (stream->conninfo.connection) + conninfo = &stream->conninfo; + else + conninfo = &src->conninfo; + + GST_DEBUG_OBJECT (src, "sending %u bytes backchannel RTP", size); + ret = gst_rtspsrc_connection_send (src, conninfo, &message, NULL); + GST_DEBUG_OBJECT (src, "sent backchannel RTP, %d", ret); + + /* and steal it away again because we will free it when unreffing the + * buffer */ + gst_rtsp_message_steal_body (&message, &data, &size); + gst_rtsp_message_unset (&message); + + gst_buffer_unmap (buffer, &map); + + res = GST_FLOW_OK; + } else { + g_signal_emit_by_name (stream->rtpsrc, "push-sample", sample, &res); + GST_DEBUG_OBJECT (src, "sent backchannel RTP sample %p: %s", sample, + gst_flow_get_name (res)); + } + +out: + gst_sample_unref (sample); + + return res; +} + +static GstPadProbeReturn +pad_blocked (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + GstRTSPSrc *src = user_data; GST_DEBUG_OBJECT (src, "pad %s:%s blocked, activating streams", GST_DEBUG_PAD_NAME (pad)); @@ -2695,6 +3367,24 @@ was_ok: } } +static GstPadProbeReturn +udpsrc_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + guint32 *segment_seqnum = user_data; + + switch (GST_EVENT_TYPE (info->data)) { + case GST_EVENT_SEGMENT: + if (!gst_event_is_writable (info->data)) + info->data = gst_event_make_writable (info->data); + + *segment_seqnum = gst_event_get_seqnum (info->data); + default: + break; + } + + return GST_PAD_PROBE_OK; +} + static gboolean copy_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { @@ -2706,6 +3396,35 @@ copy_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) return TRUE; } +static gboolean +add_backchannel_fakesink (GstRTSPSrc * src, GstRTSPStream * stream, + GstPad * srcpad) +{ + GstPad *sinkpad; + GstElement *fakesink; + + fakesink = gst_element_factory_make ("fakesink", NULL); + if (fakesink == NULL) { + GST_ERROR_OBJECT (src, "no fakesink"); + return FALSE; + } + + sinkpad = gst_element_get_static_pad (fakesink, "sink"); + + GST_DEBUG_OBJECT (src, "backchannel stream %p, hooking fakesink", stream); + + gst_bin_add (GST_BIN_CAST (src), fakesink); + if (gst_pad_link (srcpad, sinkpad) != GST_PAD_LINK_OK) { + GST_WARNING_OBJECT (src, "could not link to fakesink"); + return FALSE; + } + + gst_object_unref (sinkpad); + + gst_element_sync_state_with_parent (fakesink); + return TRUE; +} + /* this callback is called when the session manager generated a new src pad with * payloaded RTP packets. We simply ghost the pad here. */ static void @@ -2773,7 +3492,12 @@ new_manager_pad (GstElement * manager, GstPad * pad, GstRTSPSrc * src) gst_pad_set_query_function (stream->srcpad, gst_rtspsrc_handle_src_query); gst_pad_set_active (stream->srcpad, TRUE); gst_pad_sticky_events_foreach (pad, copy_sticky_events, stream->srcpad); - gst_element_add_pad (GST_ELEMENT_CAST (src), stream->srcpad); + + /* don't add the srcpad if this is a sendonly stream */ + if (stream->is_backchannel) + add_backchannel_fakesink (src, stream, stream->srcpad); + else + gst_element_add_pad (GST_ELEMENT_CAST (src), stream->srcpad); if (all_added) { GST_DEBUG_OBJECT (src, "We added all streams"); @@ -2871,7 +3595,7 @@ on_bye_ssrc (GObject * session, GObject * source, GstRTSPStream * stream) } static void -on_timeout (GObject * session, GObject * source, GstRTSPStream * stream) +on_timeout_common (GObject * session, GObject * source, GstRTSPStream * stream) { GstRTSPSrc *src = stream->parent; guint ssrc; @@ -2886,6 +3610,22 @@ on_timeout (GObject * session, GObject * source, GstRTSPStream * stream) } static void +on_timeout (GObject * session, GObject * source, GstRTSPStream * stream) +{ + GstRTSPSrc *src = stream->parent; + + /* timeout, post element message */ + gst_element_post_message (GST_ELEMENT_CAST (src), + gst_message_new_element (GST_OBJECT_CAST (src), + gst_structure_new ("GstRTSPSrcTimeout", + "cause", G_TYPE_ENUM, GST_RTSP_SRC_TIMEOUT_CAUSE_RTCP, + "stream-number", G_TYPE_INT, stream->id, "ssrc", G_TYPE_UINT, + stream->ssrc, NULL))); + + on_timeout_common (session, source, stream); +} + +static void on_npt_stop (GstElement * rtpbin, guint session, guint ssrc, GstRTSPSrc * src) { GstRTSPStream *stream; @@ -3232,6 +3972,12 @@ gst_rtspsrc_stream_configure_manager (GstRTSPSrc * src, GstRTSPStream * stream, if (!(src->manager = gst_element_factory_make (manager, "manager"))) goto manager_failed; } +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + if (g_strcmp0 (manager, "rtpbin") == 0) { + /* set for player rtsp buffering */ + g_object_set (src->manager, "use-rtsp-buffering", TRUE, NULL); + } +#endif /* we manage this element */ gst_element_set_locked_state (src->manager, TRUE); @@ -3402,8 +4148,8 @@ gst_rtspsrc_stream_configure_manager (GstRTSPSrc * src, GstRTSPStream * stream, g_signal_connect (rtpsession, "on-bye-ssrc", (GCallback) on_bye_ssrc, stream); - g_signal_connect (rtpsession, "on-bye-timeout", (GCallback) on_timeout, - stream); + g_signal_connect (rtpsession, "on-bye-timeout", + (GCallback) on_timeout_common, stream); g_signal_connect (rtpsession, "on-timeout", (GCallback) on_timeout, stream); g_signal_connect (rtpsession, "on-ssrc-active", @@ -3667,7 +4413,7 @@ gst_rtspsrc_stream_configure_mcast (GstRTSPSrc * src, GstRTSPStream * stream, gst_object_ref_sink (stream->udpsrc[1]); if (src->multi_iface != NULL) - g_object_set (G_OBJECT (stream->udpsrc[0]), "multicast-iface", + g_object_set (G_OBJECT (stream->udpsrc[1]), "multicast-iface", src->multi_iface, NULL); gst_element_set_state (stream->udpsrc[1], GST_STATE_READY); @@ -3730,6 +4476,10 @@ gst_rtspsrc_stream_configure_udp (GstRTSPSrc * src, GstRTSPStream * stream, GST_PAD_PROBE_TYPE_BLOCK | GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_BUFFER_LIST, pad_blocked, src, NULL); + gst_pad_add_probe (stream->blockedpad, + GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, udpsrc_probe_cb, + &(stream->segment_seqnum[0]), NULL); + if (stream->channelpad[0]) { GST_DEBUG_OBJECT (src, "connecting UDP source 0 to manager"); /* configure for UDP delivery, we need to connect the UDP pads to @@ -3765,6 +4515,9 @@ gst_rtspsrc_stream_configure_udp (GstRTSPSrc * src, GstRTSPStream * stream, GST_DEBUG_OBJECT (src, "connecting UDP source 1 to manager"); pad = gst_element_get_static_pad (stream->udpsrc[1], "src"); + gst_pad_add_probe (pad, + GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, udpsrc_probe_cb, + &(stream->segment_seqnum[1]), NULL); gst_pad_link_full (pad, stream->channelpad[1], GST_PAD_LINK_CHECK_NOTHING); gst_object_unref (pad); @@ -3803,7 +4556,7 @@ gst_rtspsrc_stream_configure_udp_sinks (GstRTSPSrc * src, goto no_destination; /* try to construct the fakesrc to the RTP port of the server to open up any - * NAT firewalls */ + * NAT firewalls or, if backchannel, construct an appsrc */ if (do_rtp) { GST_DEBUG_OBJECT (src, "configure RTP UDP sink for %s:%d", destination, rtp_port); @@ -3837,25 +4590,36 @@ gst_rtspsrc_stream_configure_udp_sinks (GstRTSPSrc * src, g_object_unref (socket); } - /* the source for the dummy packets to open up NAT */ - stream->fakesrc = gst_element_factory_make ("fakesrc", NULL); - if (stream->fakesrc == NULL) - goto no_fakesrc_element; + if (stream->is_backchannel) { + /* appsrc is for the app to shovel data using push-backchannel-buffer */ + stream->rtpsrc = gst_element_factory_make ("appsrc", NULL); + if (stream->rtpsrc == NULL) + goto no_appsrc_element; - /* random data in 5 buffers, a size of 200 bytes should be fine */ - g_object_set (G_OBJECT (stream->fakesrc), "filltype", 3, "num-buffers", 5, - "sizetype", 2, "sizemax", 200, "silent", TRUE, NULL); + /* interal use only, don't emit signals */ + g_object_set (G_OBJECT (stream->rtpsrc), "emit-signals", TRUE, + "is-live", TRUE, NULL); + } else { + /* the source for the dummy packets to open up NAT */ + stream->rtpsrc = gst_element_factory_make ("fakesrc", NULL); + if (stream->rtpsrc == NULL) + goto no_fakesrc_element; + + /* random data in 5 buffers, a size of 200 bytes should be fine */ + g_object_set (G_OBJECT (stream->rtpsrc), "filltype", 3, "num-buffers", 5, + "sizetype", 2, "sizemax", 200, "silent", TRUE, NULL); + } /* keep everything locked */ gst_element_set_locked_state (stream->udpsink[0], TRUE); - gst_element_set_locked_state (stream->fakesrc, TRUE); + gst_element_set_locked_state (stream->rtpsrc, TRUE); gst_object_ref (stream->udpsink[0]); gst_bin_add (GST_BIN_CAST (src), stream->udpsink[0]); - gst_object_ref (stream->fakesrc); - gst_bin_add (GST_BIN_CAST (src), stream->fakesrc); + gst_object_ref (stream->rtpsrc); + gst_bin_add (GST_BIN_CAST (src), stream->rtpsrc); - gst_element_link_pads_full (stream->fakesrc, "src", stream->udpsink[0], + gst_element_link_pads_full (stream->rtpsrc, "src", stream->udpsink[0], "sink", GST_PAD_LINK_CHECK_NOTHING); } if (do_rtcp) { @@ -3926,6 +4690,11 @@ no_sink_element: GST_ERROR_OBJECT (src, "no UDP sink element found"); return FALSE; } +no_appsrc_element: + { + GST_ERROR_OBJECT (src, "no appsrc element found"); + return FALSE; + } no_fakesrc_element: { GST_ERROR_OBJECT (src, "no fakesrc element found"); @@ -3999,8 +4768,8 @@ gst_rtspsrc_stream_configure_transport (GstRTSPStream * stream, case GST_RTSP_LOWER_TRANS_UDP: if (!gst_rtspsrc_stream_configure_udp (src, stream, transport, &outpad)) goto transport_failed; - /* configure udpsinks back to the server for RTCP messages and for the - * dummy RTP messages to open NAT. */ + /* configure udpsinks back to the server for RTCP messages, for the + * dummy RTP messages to open NAT, and for the backchannel */ if (!gst_rtspsrc_stream_configure_udp_sinks (src, stream, transport)) goto transport_failed; break; @@ -4008,8 +4777,12 @@ gst_rtspsrc_stream_configure_transport (GstRTSPStream * stream, goto unknown_transport; } - if (outpad) { - GST_DEBUG_OBJECT (src, "creating ghostpad"); + /* using backchannel and no manager, hence no srcpad for this stream */ + if (outpad && stream->is_backchannel) { + add_backchannel_fakesink (src, stream, outpad); + gst_object_unref (outpad); + } else if (outpad) { + GST_DEBUG_OBJECT (src, "creating ghostpad for stream %p", stream); gst_pad_use_fixed_caps (outpad); @@ -4033,17 +4806,17 @@ gst_rtspsrc_stream_configure_transport (GstRTSPStream * stream, /* ERRORS */ transport_failed: { - GST_DEBUG_OBJECT (src, "failed to configure transport"); + GST_WARNING_OBJECT (src, "failed to configure transport"); return FALSE; } unknown_transport: { - GST_DEBUG_OBJECT (src, "unknown transport"); + GST_WARNING_OBJECT (src, "unknown transport"); return FALSE; } no_manager: { - GST_DEBUG_OBJECT (src, "cannot get a session manager"); + GST_WARNING_OBJECT (src, "cannot get a session manager"); return FALSE; } } @@ -4062,13 +4835,18 @@ gst_rtspsrc_send_dummy_packets (GstRTSPSrc * src) for (walk = src->streams; walk; walk = g_list_next (walk)) { GstRTSPStream *stream = (GstRTSPStream *) walk->data; - if (stream->fakesrc && stream->udpsink[0]) { + if (!stream->rtpsrc || !stream->udpsink[0]) + continue; + + if (stream->is_backchannel) + GST_DEBUG_OBJECT (src, "starting backchannel stream %p", stream); + else GST_DEBUG_OBJECT (src, "sending dummy packet to stream %p", stream); - gst_element_set_state (stream->udpsink[0], GST_STATE_NULL); - gst_element_set_state (stream->fakesrc, GST_STATE_NULL); - gst_element_set_state (stream->udpsink[0], GST_STATE_PLAYING); - gst_element_set_state (stream->fakesrc, GST_STATE_PLAYING); - } + + gst_element_set_state (stream->udpsink[0], GST_STATE_NULL); + gst_element_set_state (stream->rtpsrc, GST_STATE_NULL); + gst_element_set_state (stream->udpsink[0], GST_STATE_PLAYING); + gst_element_set_state (stream->rtpsrc, GST_STATE_PLAYING); } return TRUE; } @@ -4110,7 +4888,10 @@ gst_rtspsrc_activate_streams (GstRTSPSrc * src) /* add the pad */ if (!stream->added) { GST_DEBUG_OBJECT (src, "adding stream pad %p", stream); - gst_element_add_pad (GST_ELEMENT_CAST (src), stream->srcpad); + if (stream->is_backchannel) + add_backchannel_fakesink (src, stream, stream->srcpad); + else + gst_element_add_pad (GST_ELEMENT_CAST (src), stream->srcpad); stream->added = TRUE; } } @@ -4236,8 +5017,16 @@ gst_rtspsrc_stream_push_event (GstRTSPSrc * src, GstRTSPStream * stream, goto done; if (stream->udpsrc[0]) { - gst_event_ref (event); - res = gst_element_send_event (stream->udpsrc[0], event); + GstEvent *sent_event; + + if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) { + sent_event = gst_event_new_eos (); + gst_event_set_seqnum (sent_event, stream->segment_seqnum[0]); + } else { + sent_event = gst_event_ref (event); + } + + res = gst_element_send_event (stream->udpsrc[0], sent_event); } else if (stream->channelpad[0]) { gst_event_ref (event); if (GST_PAD_IS_SRC (stream->channelpad[0])) @@ -4247,8 +5036,18 @@ gst_rtspsrc_stream_push_event (GstRTSPSrc * src, GstRTSPStream * stream, } if (stream->udpsrc[1]) { - gst_event_ref (event); - res &= gst_element_send_event (stream->udpsrc[1], event); + GstEvent *sent_event; + + if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) { + sent_event = gst_event_new_eos (); + if (stream->segment_seqnum[1] != GST_SEQNUM_INVALID) { + gst_event_set_seqnum (sent_event, stream->segment_seqnum[1]); + } + } else { + sent_event = gst_event_ref (event); + } + + res &= gst_element_send_event (stream->udpsrc[1], sent_event); } else if (stream->channelpad[1]) { gst_event_ref (event); if (GST_PAD_IS_SRC (stream->channelpad[1])) @@ -4280,6 +5079,19 @@ gst_rtspsrc_push_event (GstRTSPSrc * src, GstEvent * event) return res; } +static gboolean +accept_certificate_cb (GTlsConnection * conn, GTlsCertificate * peer_cert, + GTlsCertificateFlags errors, gpointer user_data) +{ + GstRTSPSrc *src = user_data; + gboolean accept = FALSE; + + g_signal_emit (src, gst_rtspsrc_signals[SIGNAL_ACCEPT_CERTIFICATE], 0, conn, + peer_cert, errors, &accept); + + return accept; +} + static GstRTSPResult gst_rtsp_conninfo_connect (GstRTSPSrc * src, GstRTSPConnInfo * info, gboolean async) @@ -4322,6 +5134,8 @@ gst_rtsp_conninfo_connect (GstRTSPSrc * src, GstRTSPConnInfo * info, if (src->tls_interaction) gst_rtsp_connection_set_tls_interaction (info->connection, src->tls_interaction); + gst_rtsp_connection_set_accept_certificate_func (info->connection, + accept_certificate_cb, src, NULL); } if (info->url->transports & GST_RTSP_LOWER_TRANS_HTTP) @@ -4896,8 +5710,13 @@ receive_error: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_SERVER, + "Could not receive message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Could not receive message. (%s)", str)); +#endif g_free (str); gst_rtsp_message_unset (&message); @@ -4907,8 +5726,13 @@ handle_request_failed: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_SERVICE_UNAVAILABLE, + "Could not handle server message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Could not handle server message. (%s)", str)); +#endif g_free (str); gst_rtsp_message_unset (&message); return GST_FLOW_ERROR; @@ -5028,8 +5852,13 @@ connect_error: src->conninfo.connected = FALSE; if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONNECTION_FAIL, + "Could not connect to server."); +#else GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL), ("Could not connect to server. (%s)", str)); +#endif g_free (str); ret = GST_FLOW_ERROR; } else { @@ -5041,8 +5870,13 @@ receive_error: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_SERVER_DISCONNECTED, + "Could not receive message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Could not receive message. (%s)", str)); +#endif g_free (str); return GST_FLOW_ERROR; } @@ -5053,8 +5887,14 @@ handle_request_failed: gst_rtsp_message_unset (&message); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, + GST_RTSPSRC_ERROR_SERVICE_UNAVAILABLE, + "Could not handle server message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Could not handle server message. (%s)", str)); +#endif g_free (str); ret = GST_FLOW_ERROR; } else { @@ -5126,10 +5966,15 @@ no_protocols: { src->cur_protocols = 0; /* no transport possible, post an error and stop */ +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_TRANSPORT, + "Could not receive any UDP packets for seconds, maybe your firewall is blocking it. No other protocols to try."); +#else GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Could not receive any UDP packets for %.4f seconds, maybe your " "firewall is blocking it. No other protocols to try.", gst_guint64_to_gdouble (src->udp_timeout) / 1000000.0)); +#endif return GST_RTSP_ERROR; } open_failed: @@ -5157,6 +6002,14 @@ gst_rtspsrc_loop_start_cmd (GstRTSPSrc * src, gint cmd) case CMD_PAUSE: GST_ELEMENT_PROGRESS (src, START, "request", ("Sending PAUSE request")); break; + case CMD_GET_PARAMETER: + GST_ELEMENT_PROGRESS (src, START, "request", + ("Sending GET_PARAMETER request")); + break; + case CMD_SET_PARAMETER: + GST_ELEMENT_PROGRESS (src, START, "request", + ("Sending SET_PARAMETER request")); + break; case CMD_CLOSE: GST_ELEMENT_PROGRESS (src, START, "close", ("Closing Stream")); break; @@ -5168,9 +6021,38 @@ gst_rtspsrc_loop_start_cmd (GstRTSPSrc * src, gint cmd) static void gst_rtspsrc_loop_complete_cmd (GstRTSPSrc * src, gint cmd) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + GstMessage *s; + GST_WARNING_OBJECT (src, "Got cmd %s", cmd_to_string (cmd)); +#endif + switch (cmd) { case CMD_OPEN: +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + GST_DEBUG_OBJECT (src, + "rtsp_duration %" GST_TIME_FORMAT + ", rtsp_audio_codec %s , rtsp_video_codec %s , rtsp_video_frame_size %s", + GST_TIME_ARGS (src->segment.duration), src->audio_codec, + src->video_codec, src->video_frame_size); + + /* post message */ + s = gst_message_new_element (GST_OBJECT_CAST (src), + gst_structure_new ("rtspsrc_properties", + "rtsp_duration", G_TYPE_UINT64, src->segment.duration, + "rtsp_audio_codec", G_TYPE_STRING, src->audio_codec, + "rtsp_video_codec", G_TYPE_STRING, src->video_codec, + "rtsp_video_frame_size", G_TYPE_STRING, src->video_frame_size, + NULL)); + + gst_element_post_message (GST_ELEMENT_CAST (src), s); +#endif GST_ELEMENT_PROGRESS (src, COMPLETE, "open", ("Opened Stream")); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + /* rtspsrc PAUSE state should be here for parsing sdp before PAUSE state changed. */ + g_mutex_lock (&(src)->pause_lock); + g_cond_signal (&(src)->open_end); + g_mutex_unlock (&(src)->pause_lock); +#endif break; case CMD_PLAY: GST_ELEMENT_PROGRESS (src, COMPLETE, "request", ("Sent PLAY request")); @@ -5178,6 +6060,14 @@ gst_rtspsrc_loop_complete_cmd (GstRTSPSrc * src, gint cmd) case CMD_PAUSE: GST_ELEMENT_PROGRESS (src, COMPLETE, "request", ("Sent PAUSE request")); break; + case CMD_GET_PARAMETER: + GST_ELEMENT_PROGRESS (src, COMPLETE, "request", + ("Sent GET_PARAMETER request")); + break; + case CMD_SET_PARAMETER: + GST_ELEMENT_PROGRESS (src, COMPLETE, "request", + ("Sent SET_PARAMETER request")); + break; case CMD_CLOSE: GST_ELEMENT_PROGRESS (src, COMPLETE, "close", ("Closed Stream")); break; @@ -5199,6 +6089,14 @@ gst_rtspsrc_loop_cancel_cmd (GstRTSPSrc * src, gint cmd) case CMD_PAUSE: GST_ELEMENT_PROGRESS (src, CANCELED, "request", ("PAUSE canceled")); break; + case CMD_GET_PARAMETER: + GST_ELEMENT_PROGRESS (src, CANCELED, "request", + ("GET_PARAMETER canceled")); + break; + case CMD_SET_PARAMETER: + GST_ELEMENT_PROGRESS (src, CANCELED, "request", + ("SET_PARAMETER canceled")); + break; case CMD_CLOSE: GST_ELEMENT_PROGRESS (src, CANCELED, "close", ("Close canceled")); break; @@ -5213,6 +6111,14 @@ gst_rtspsrc_loop_error_cmd (GstRTSPSrc * src, gint cmd) switch (cmd) { case CMD_OPEN: GST_ELEMENT_PROGRESS (src, ERROR, "open", ("Open failed")); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + /* Ending conditional wait for pause when open fails.*/ + g_mutex_lock (&(src)->pause_lock); + g_cond_signal (&(src)->open_end); + g_mutex_unlock (&(src)->pause_lock); + GST_WARNING_OBJECT (src, + "ending conditional wait for pause as open is failed."); +#endif break; case CMD_PLAY: GST_ELEMENT_PROGRESS (src, ERROR, "request", ("PLAY failed")); @@ -5220,6 +6126,12 @@ gst_rtspsrc_loop_error_cmd (GstRTSPSrc * src, gint cmd) case CMD_PAUSE: GST_ELEMENT_PROGRESS (src, ERROR, "request", ("PAUSE failed")); break; + case CMD_GET_PARAMETER: + GST_ELEMENT_PROGRESS (src, ERROR, "request", ("GET_PARAMETER failed")); + break; + case CMD_SET_PARAMETER: + GST_ELEMENT_PROGRESS (src, ERROR, "request", ("SET_PARAMETER failed")); + break; case CMD_CLOSE: GST_ELEMENT_PROGRESS (src, ERROR, "close", ("Close failed")); break; @@ -5252,6 +6164,7 @@ gst_rtspsrc_loop_send_cmd (GstRTSPSrc * src, gint cmd, gint mask) GST_OBJECT_LOCK (src); old = src->pending_cmd; + if (old == CMD_RECONNECT) { GST_DEBUG_OBJECT (src, "ignore, we were reconnecting"); cmd = CMD_RECONNECT; @@ -5262,6 +6175,12 @@ gst_rtspsrc_loop_send_cmd (GstRTSPSrc * src, gint cmd, gint mask) * still the pending command. */ GST_DEBUG_OBJECT (src, "ignore, we were closing"); cmd = CMD_CLOSE; + } else if (old == CMD_SET_PARAMETER) { + GST_DEBUG_OBJECT (src, "ignore, we have a pending %s", cmd_to_string (old)); + cmd = CMD_SET_PARAMETER; + } else if (old == CMD_GET_PARAMETER) { + GST_DEBUG_OBJECT (src, "ignore, we have a pending %s", cmd_to_string (old)); + cmd = CMD_GET_PARAMETER; } else if (old != CMD_WAIT) { src->pending_cmd = CMD_WAIT; GST_OBJECT_UNLOCK (src); @@ -5289,6 +6208,28 @@ gst_rtspsrc_loop_send_cmd (GstRTSPSrc * src, gint cmd, gint mask) } static gboolean +gst_rtspsrc_loop_send_cmd_and_wait (GstRTSPSrc * src, gint cmd, gint mask, + GstClockTime timeout) +{ + gboolean flushed = gst_rtspsrc_loop_send_cmd (src, cmd, mask); + + if (timeout > 0) { + gint64 end_time = g_get_monotonic_time () + (timeout / 1000); + GST_OBJECT_LOCK (src); + while (src->pending_cmd == cmd || src->busy_cmd == cmd) { + if (!g_cond_wait_until (&src->cmd_cond, GST_OBJECT_GET_LOCK (src), + end_time)) { + GST_WARNING_OBJECT (src, + "Timed out waiting for TEARDOWN to be processed."); + break; /* timeout passed */ + } + } + GST_OBJECT_UNLOCK (src); + } + return flushed; +} + +static gboolean gst_rtspsrc_loop (GstRTSPSrc * src) { GstFlowReturn ret; @@ -5509,8 +6450,13 @@ no_auth_available: { /* Output an error indicating that we couldn't connect because there were * no supported authentication protocols */ +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_NOT_AUTHORIZED, + "No supported authentication protocol was found"); +#else GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("No supported authentication protocol was found")); +#endif return FALSE; } no_user_pass: @@ -5597,8 +6543,14 @@ receive_error: gchar *str = gst_rtsp_strresult (res); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, + GST_RTSPSRC_ERROR_SERVER_DISCONNECTED, + "Could not receive message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Could not receive message. (%s)", str)); +#endif } else { GST_WARNING_OBJECT (src, "receive interrupted"); } @@ -5632,11 +6584,19 @@ gst_rtspsrc_try_send (GstRTSPSrc * src, GstRTSPConnInfo * conninfo, { GstRTSPResult res; gint try = 0; + gboolean allow_send = TRUE; again: if (!src->short_header) gst_rtsp_ext_list_before_send (src->extensions, request); + g_signal_emit (src, gst_rtspsrc_signals[SIGNAL_BEFORE_SEND], 0, + request, &allow_send); + if (!allow_send) { + GST_DEBUG_OBJECT (src, "skipping message, disabled by signal"); + return GST_RTSP_OK; + } + GST_DEBUG_OBJECT (src, "sending message"); DEBUG_RTSP (src, request); @@ -5669,8 +6629,13 @@ send_error: gchar *str = gst_rtsp_strresult (res); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONNECTION_FAIL, + "Could not send message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Could not send message. (%s)", str)); +#endif } else { GST_WARNING_OBJECT (src, "send interrupted"); } @@ -5746,7 +6711,8 @@ gst_rtspsrc_send (GstRTSPSrc * src, GstRTSPConnInfo * conninfo, break; case GST_RTSP_STS_RTSP_VERSION_NOT_SUPPORTED: GST_INFO_OBJECT (src, "Version %s not supported by the server", - gst_rtsp_version_as_text (versions[version_retry])); + versions ? gst_rtsp_version_as_text (versions[version_retry]) : + "unknown"); if (versions && versions[version_retry] != GST_RTSP_VERSION_INVALID) { GST_INFO_OBJECT (src, "Unsupported version %s => trying %s", gst_rtsp_version_as_text (request->type_data.request.version), @@ -5783,12 +6749,22 @@ error_response: switch (response->type_data.response.code) { case GST_RTSP_STS_NOT_FOUND: +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_REQUEST, + "STS NOT FOUND"); +#else RTSP_SRC_RESPONSE_ERROR (src, response, RESOURCE, NOT_FOUND, "Not found"); +#endif break; case GST_RTSP_STS_UNAUTHORIZED: +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_NOT_AUTHORIZED, + "STS NOT AUTHORIZED"); +#else RTSP_SRC_RESPONSE_ERROR (src, response, RESOURCE, NOT_AUTHORIZED, "Unauthorized"); +#endif break; case GST_RTSP_STS_MOVED_PERMANENTLY: case GST_RTSP_STS_MOVE_TEMPORARILY: @@ -5832,8 +6808,13 @@ error_response: res = GST_RTSP_OK; break; default: +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_UNEXPECTED_MSG, + "Got error response from Server"); +#else RTSP_SRC_RESPONSE_ERROR (src, response, RESOURCE, READ, "Unhandled error"); +#endif break; } /* if we return ERROR we should unset the response ourselves */ @@ -5903,7 +6884,7 @@ gst_rtspsrc_parse_methods (GstRTSPSrc * src, GstRTSPMessage * response) * this */ src->methods |= GST_RTSP_PLAY; /* also assume it will support Range */ - src->seekable = G_MAXDOUBLE; + src->seekable = G_MAXFLOAT; /* we need describe and setup */ if (!(src->methods & GST_RTSP_DESCRIBE)) @@ -5916,14 +6897,24 @@ gst_rtspsrc_parse_methods (GstRTSPSrc * src, GstRTSPMessage * response) /* ERRORS */ no_describe: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_METHOD_NOT_ALLOWED, + "Server does not support DESCRIBE."); +#else GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Server does not support DESCRIBE.")); +#endif return FALSE; } no_setup: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_METHOD_NOT_ALLOWED, + "Server does not support SETUP."); +#else GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Server does not support SETUP.")); +#endif return FALSE; } } @@ -6282,7 +7273,7 @@ gst_rtsp_src_setup_stream_from_response (GstRTSPSrc * src, gchar **random_seekable_val = g_strsplit (prop, "=", 2); if (!random_seekable_val[1]) - src->seekable = G_MAXDOUBLE; + src->seekable = G_MAXFLOAT; else src->seekable = g_ascii_strtod (random_seekable_val[1], NULL); @@ -6410,7 +7401,7 @@ gst_rtspsrc_setup_streams_start (GstRTSPSrc * src, gboolean async) caps = stream_get_caps_for_pt (stream, stream->default_pt); if (caps == NULL) { - GST_DEBUG_OBJECT (src, "skipping stream %p, no caps", stream); + GST_WARNING_OBJECT (src, "skipping stream %p, no caps", stream); continue; } @@ -6455,13 +7446,14 @@ gst_rtspsrc_setup_streams_start (GstRTSPSrc * src, gboolean async) /* skip setup if we have no URL for it */ if (stream->conninfo.location == NULL) { - GST_DEBUG_OBJECT (src, "skipping stream %p, no setup", stream); + GST_WARNING_OBJECT (src, "skipping stream %p, no setup", stream); continue; } if (src->conninfo.connection == NULL) { if (!gst_rtsp_conninfo_connect (src, &stream->conninfo, async)) { - GST_DEBUG_OBJECT (src, "skipping stream %p, failed to connect", stream); + GST_WARNING_OBJECT (src, "skipping stream %p, failed to connect", + stream); continue; } conninfo = &stream->conninfo; @@ -6534,6 +7526,10 @@ gst_rtspsrc_setup_streams_start (GstRTSPSrc * src, gboolean async) /* select transport */ gst_rtsp_message_take_header (&request, GST_RTSP_HDR_TRANSPORT, transports); + if (stream->is_backchannel && src->backchannel == BACKCHANNEL_ONVIF) + gst_rtsp_message_add_header (&request, GST_RTSP_HDR_REQUIRE, + BACKCHANNEL_ONVIF_HDR_REQUIRE_VAL); + /* set up keys */ if (stream->profile == GST_RTSP_PROFILE_SAVP || stream->profile == GST_RTSP_PROFILE_SAVPF) { @@ -6646,6 +7642,9 @@ gst_rtspsrc_setup_streams_start (GstRTSPSrc * src, gboolean async) gst_rtsp_ext_list_stream_select (src->extensions, url); + if (pipelined_request_id) + g_free (pipelined_request_id); + /* if there is nothing to activate, error out */ if (!src->need_activate) goto nothing_to_activate; @@ -6655,39 +7654,66 @@ gst_rtspsrc_setup_streams_start (GstRTSPSrc * src, gboolean async) /* ERRORS */ no_protocols: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_INVALID_PROTOCOL, + "Could not connect to server, no protocols left"); +#else /* no transport possible, post an error and stop */ GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Could not connect to server, no protocols left")); +#endif return GST_RTSP_ERROR; } no_streams: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONTENT_NOT_FOUND, + "SDP contains no streams"); +#else GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("SDP contains no streams")); +#endif return GST_RTSP_ERROR; } create_request_failed: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_REQUEST, + "Could not create request."); +#else GST_ELEMENT_ERROR (src, LIBRARY, INIT, (NULL), ("Could not create request. (%s)", str)); +#endif g_free (str); goto cleanup_error; } setup_transport_failed: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_REQUEST, + "Could not setup transport."); +#else GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("Could not setup transport.")); +#endif res = GST_RTSP_ERROR; goto cleanup_error; } response_error: { +#ifndef TIZEN_FEATURE_RTSP_MODIFICATION const gchar *str = gst_rtsp_status_as_text (code); +#endif +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_UNEXPECTED_MSG, + "Error from Server ."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Error (%d): %s", code, GST_STR_NULL (str))); +#endif res = GST_RTSP_ERROR; goto cleanup_error; } @@ -6696,8 +7722,13 @@ send_error: gchar *str = gst_rtsp_strresult (res); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONNECTION_FAIL, + "Could not send message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Could not send message. (%s)", str)); +#endif } else { GST_WARNING_OBJECT (src, "send interrupted"); } @@ -6708,20 +7739,34 @@ nothing_to_activate: { /* none of the available error codes is really right .. */ if (unsupported_real) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, + GST_RTSPSRC_ERROR_UNSUPPORTED_MEDIA_TYPE, + "No supported stream was found. You might need to install a GStreamer RTSP extension plugin for Real media streams."); +#else GST_ELEMENT_ERROR (src, STREAM, CODEC_NOT_FOUND, (_("No supported stream was found. You might need to install a " "GStreamer RTSP extension plugin for Real media streams.")), (NULL)); +#endif } else { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, + GST_RTSPSRC_ERROR_UNSUPPORTED_MEDIA_TYPE, + "No supported stream was found. You might need to allow more transport protocols or may otherwise be missing the right GStreamer RTSP extension plugin."); +#else GST_ELEMENT_ERROR (src, STREAM, CODEC_NOT_FOUND, (_("No supported stream was found. You might need to allow " "more transport protocols or may otherwise be missing " "the right GStreamer RTSP extension plugin.")), (NULL)); +#endif } return GST_RTSP_ERROR; } cleanup_error: { + if (pipelined_request_id) + g_free (pipelined_request_id); gst_rtsp_message_unset (&request); gst_rtsp_message_unset (&response); return res; @@ -6765,10 +7810,21 @@ gst_rtspsrc_parse_range (GstRTSPSrc * src, const gchar * range, /* we need to start playback without clipping from the position reported by * the server */ segment->start = seconds; +#ifndef TIZEN_FEATURE_RTSP_MODIFICATION +/* +The range-min points to the start of the segment , not the current position. +After getting the current position from MSL during normal pause/resume or during seek , we should not +update the segment->position again with the rtp header npt timestamp. +*/ segment->position = seconds; +#endif if (therange->max.type == GST_RTSP_TIME_NOW) +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + seconds = 0; +#else seconds = -1; +#endif else if (therange->max.type == GST_RTSP_TIME_END) seconds = -1; else @@ -6943,6 +7999,11 @@ gst_rtspsrc_open_from_sdp (GstRTSPSrc * src, GstSDPMessage * sdp, src->control = g_strdup (control); } +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + src->is_audio_codec_supported = FALSE; + src->is_video_codec_supported = FALSE; +#endif + /* create streams */ n_streams = gst_sdp_message_medias_len (sdp); for (i = 0; i < n_streams; i++) { @@ -6950,7 +8011,15 @@ gst_rtspsrc_open_from_sdp (GstRTSPSrc * src, GstSDPMessage * sdp, } src->state = GST_RTSP_STATE_INIT; - +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + /* Check for the support for the Media codecs */ + if ((!src->is_audio_codec_supported) && (!src->is_video_codec_supported)) { + GST_ERROR_OBJECT (src, "UnSupported Media Type !!!! \n"); + goto unsupported_file_type; + } else { + GST_DEBUG_OBJECT (src, "Supported Media Type. \n"); + } +#endif /* setup streams */ if ((res = gst_rtspsrc_setup_streams_start (src, async)) < 0) goto setup_failed; @@ -6970,6 +8039,17 @@ setup_failed: gst_rtspsrc_cleanup (src); return res; } +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION +unsupported_file_type: + { + gst_rtspsrc_post_error_message (src, + GST_RTSPSRC_ERROR_UNSUPPORTED_MEDIA_TYPE, + "No supported stream was found"); + res = GST_RTSP_ERROR; + gst_rtspsrc_cleanup (src); + return res; + } +#endif } static GstRTSPResult @@ -7044,6 +8124,11 @@ restart: gst_rtsp_message_add_header (&request, GST_RTSP_HDR_ACCEPT, "application/sdp"); + if (src->backchannel == BACKCHANNEL_ONVIF) + gst_rtsp_message_add_header (&request, GST_RTSP_HDR_REQUIRE, + BACKCHANNEL_ONVIF_HDR_REQUIRE_VAL); + /* TODO: Handle the case when backchannel is unsupported and goto restart */ + /* send DESCRIBE */ GST_DEBUG_OBJECT (src, "send describe..."); @@ -7116,8 +8201,13 @@ restart: /* ERRORS */ no_url: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_INVALID_URL, + "No valid RTSP URL was provided"); +#else GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL), ("No valid RTSP URL was provided")); +#endif goto cleanup_error; } connect_failed: @@ -7125,8 +8215,13 @@ connect_failed: gchar *str = gst_rtsp_strresult (res); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONNECTION_FAIL, + "Failed to connect."); +#else GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL), ("Failed to connect. (%s)", str)); +#endif } else { GST_WARNING_OBJECT (src, "connect interrupted"); } @@ -7137,8 +8232,13 @@ create_request_failed: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_REQUEST, + "Could not create request."); +#else GST_ELEMENT_ERROR (src, LIBRARY, INIT, (NULL), ("Could not create request. (%s)", str)); +#endif g_free (str); goto cleanup_error; } @@ -7156,15 +8256,25 @@ methods_error: } wrong_content_type: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_OPTION_NOT_SUPPORTED, + "Server does not support SDP. "); +#else GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("Server does not support SDP, got %s.", respcont)); +#endif res = GST_RTSP_ERROR; goto cleanup_error; } no_describe: { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_METHOD_NOT_ALLOWED, + "Server can not provide an SDP."); +#else GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("Server can not provide an SDP.")); +#endif res = GST_RTSP_ERROR; goto cleanup_error; } @@ -7268,9 +8378,14 @@ gst_rtspsrc_close (GstRTSPSrc * src, gboolean async, gboolean only_close) /* do TEARDOWN */ res = gst_rtspsrc_init_request (src, &request, GST_RTSP_TEARDOWN, setup_url); + GST_LOG_OBJECT (src, "Teardown on %s", setup_url); if (res < 0) goto create_request_failed; + if (stream->is_backchannel && src->backchannel == BACKCHANNEL_ONVIF) + gst_rtsp_message_add_header (&request, GST_RTSP_HDR_REQUIRE, + BACKCHANNEL_ONVIF_HDR_REQUIRE_VAL); + if (async) GST_ELEMENT_PROGRESS (src, CONTINUE, "close", ("Closing stream")); @@ -7312,8 +8427,13 @@ create_request_failed: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_REQUEST, + "Could not create request."); +#else GST_ELEMENT_ERROR (src, LIBRARY, INIT, (NULL), ("Could not create request. (%s)", str)); +#endif g_free (str); goto close; } @@ -7323,8 +8443,13 @@ send_error: gst_rtsp_message_unset (&request); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONNECTION_FAIL, + "Could not send message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Could not send message. (%s)", str)); +#endif } else { GST_WARNING_OBJECT (src, "TEARDOWN interrupted"); } @@ -7464,7 +8589,12 @@ static gchar * gen_range_header (GstRTSPSrc * src, GstSegment * segment) { gchar val_str[G_ASCII_DTOSTR_BUF_SIZE] = { 0, }; - +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + if (src->start_position != 0 && segment->position == 0) { + segment->position = src->start_position; + src->start_position = 0; + } +#endif if (src->range && src->range->min.type == GST_RTSP_TIME_NOW) { g_strlcpy (val_str, "now", sizeof (val_str)); } else { @@ -7475,6 +8605,9 @@ gen_range_header (GstRTSPSrc * src, GstSegment * segment) ((gdouble) segment->position) / GST_SECOND); } } +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + GST_DEBUG_OBJECT (src, "Range Header Added : npt=%s-", val_str); +#endif return g_strdup_printf ("npt=%s-", val_str); } @@ -7590,13 +8723,34 @@ restart: goto create_request_failed; if (src->need_range && src->seekable >= 0.0) { +#ifndef TIZEN_FEATURE_RTSP_MODIFICATION hval = gen_range_header (src, segment); gst_rtsp_message_take_header (&request, GST_RTSP_HDR_RANGE, hval); +#endif /* store the newsegment event so it can be sent from the streaming thread. */ src->need_segment = TRUE; } +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + else { +/* + Updating position with the MSL current position as gst_rtspsrc_get_position() does not return correct position. +*/ + GST_DEBUG_OBJECT (src, + " During normal pause-resume , segment->position=%" GST_TIME_FORMAT + ",src->start_position=%" GST_TIME_FORMAT, + GST_TIME_ARGS (segment->position), + GST_TIME_ARGS (src->start_position)); + segment->position = src->last_pos; + } + +/* + Sending the npt range request for each play request for updating the segment position properly. +*/ + hval = gen_range_header (src, segment); + gst_rtsp_message_take_header (&request, GST_RTSP_HDR_RANGE, hval); +#endif if (segment->rate != 1.0) { gchar hval[G_ASCII_DTOSTR_BUF_SIZE]; @@ -7612,6 +8766,13 @@ restart: gst_rtsp_message_add_header (&request, GST_RTSP_HDR_SEEK_STYLE, seek_style); + /* when we have an ONVIF audio backchannel, the PLAY request must have the + * Require: header when doing either aggregate or non-aggregate control */ + if (src->backchannel == BACKCHANNEL_ONVIF && + (control || stream->is_backchannel)) + gst_rtsp_message_add_header (&request, GST_RTSP_HDR_REQUIRE, + BACKCHANNEL_ONVIF_HDR_REQUIRE_VAL); + if (async) GST_ELEMENT_PROGRESS (src, CONTINUE, "request", ("Sending PLAY request")); @@ -7732,25 +8893,30 @@ done: /* ERRORS */ open_failed: { - GST_DEBUG_OBJECT (src, "failed to open stream"); + GST_WARNING_OBJECT (src, "failed to open stream"); goto done; } not_supported: { - GST_DEBUG_OBJECT (src, "PLAY is not supported"); + GST_WARNING_OBJECT (src, "PLAY is not supported"); goto done; } was_playing: { - GST_DEBUG_OBJECT (src, "we were already PLAYING"); + GST_WARNING_OBJECT (src, "we were already PLAYING"); goto done; } create_request_failed: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_REQUEST, + "Could not create request. "); +#else GST_ELEMENT_ERROR (src, LIBRARY, INIT, (NULL), ("Could not create request. (%s)", str)); +#endif g_free (str); goto done; } @@ -7760,8 +8926,13 @@ send_error: gst_rtsp_message_unset (&request); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONNECTION_FAIL, + "Could not send message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Could not send message. (%s)", str)); +#endif } else { GST_WARNING_OBJECT (src, "PLAY interrupted"); } @@ -7826,6 +8997,13 @@ gst_rtspsrc_pause (GstRTSPSrc * src, gboolean async) setup_url)) < 0) goto create_request_failed; + /* when we have an ONVIF audio backchannel, the PAUSE request must have the + * Require: header when doing either aggregate or non-aggregate control */ + if (src->backchannel == BACKCHANNEL_ONVIF && + (control || stream->is_backchannel)) + gst_rtsp_message_add_header (&request, GST_RTSP_HDR_REQUIRE, + BACKCHANNEL_ONVIF_HDR_REQUIRE_VAL); + if ((res = gst_rtspsrc_send (src, conninfo, &request, &response, NULL, NULL)) < 0) @@ -7871,8 +9049,13 @@ create_request_failed: { gchar *str = gst_rtsp_strresult (res); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_BAD_REQUEST, + "Could not create request."); +#else GST_ELEMENT_ERROR (src, LIBRARY, INIT, (NULL), ("Could not create request. (%s)", str)); +#endif g_free (str); goto done; } @@ -7882,8 +9065,13 @@ send_error: gst_rtsp_message_unset (&request); if (res != GST_RTSP_EINTR) { +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + gst_rtspsrc_post_error_message (src, GST_RTSPSRC_ERROR_CONNECTION_FAIL, + "Could not send message."); +#else GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Could not send message. (%s)", str)); +#endif } else { GST_WARNING_OBJECT (src, "PAUSE interrupted"); } @@ -7977,13 +9165,22 @@ static void gst_rtspsrc_thread (GstRTSPSrc * src) { gint cmd; + ParameterRequest *req = NULL; GST_OBJECT_LOCK (src); cmd = src->pending_cmd; if (cmd == CMD_RECONNECT || cmd == CMD_PLAY || cmd == CMD_PAUSE - || cmd == CMD_LOOP || cmd == CMD_OPEN) - src->pending_cmd = CMD_LOOP; - else + || cmd == CMD_LOOP || cmd == CMD_OPEN || cmd == CMD_GET_PARAMETER + || cmd == CMD_SET_PARAMETER) { + if (g_queue_is_empty (&src->set_get_param_q)) { + src->pending_cmd = CMD_LOOP; + } else { + ParameterRequest *next_req; + req = g_queue_pop_head (&src->set_get_param_q); + next_req = g_queue_peek_head (&src->set_get_param_q); + src->pending_cmd = next_req ? next_req->cmd : CMD_LOOP; + } + } else src->pending_cmd = CMD_WAIT; GST_DEBUG_OBJECT (src, "got command %s", cmd_to_string (cmd)); @@ -8006,6 +9203,12 @@ gst_rtspsrc_thread (GstRTSPSrc * src) case CMD_CLOSE: gst_rtspsrc_close (src, TRUE, FALSE); break; + case CMD_GET_PARAMETER: + gst_rtspsrc_get_parameter (src, req); + break; + case CMD_SET_PARAMETER: + gst_rtspsrc_set_parameter (src, req); + break; case CMD_LOOP: gst_rtspsrc_loop (src); break; @@ -8017,6 +9220,8 @@ gst_rtspsrc_thread (GstRTSPSrc * src) } GST_OBJECT_LOCK (src); + /* No more cmds, wake any waiters */ + g_cond_broadcast (&src->cmd_cond); /* and go back to sleep */ if (src->pending_cmd == CMD_WAIT) { if (src->task) @@ -8098,8 +9303,14 @@ gst_rtspsrc_change_state (GstElement * element, GstStateChange transition) { GstRTSPSrc *rtspsrc; GstStateChangeReturn ret; +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + guint64 end_time; +#endif rtspsrc = GST_RTSPSRC (element); +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + GST_WARNING_OBJECT (rtspsrc, "State change transition: %d \n", transition); +#endif switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: @@ -8140,6 +9351,18 @@ gst_rtspsrc_change_state (GstElement * element, GstStateChange transition) ret = GST_STATE_CHANGE_SUCCESS; break; case GST_STATE_CHANGE_READY_TO_PAUSED: +#ifdef TIZEN_FEATURE_RTSP_MODIFICATION + /* don't change to PAUSE state before complete stream opend. + see gst_rtspsrc_loop_complete_cmd() */ + g_mutex_lock (&(rtspsrc)->pause_lock); + end_time = g_get_monotonic_time () + 10 * G_TIME_SPAN_SECOND; + if (!g_cond_wait_until (&(rtspsrc)->open_end, &(rtspsrc)->pause_lock, + end_time)) { + GST_WARNING_OBJECT (rtspsrc, + "time out: stream opend is not completed yet.."); + } + g_mutex_unlock (&(rtspsrc)->pause_lock); +#endif ret = GST_STATE_CHANGE_NO_PREROLL; break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: @@ -8152,7 +9375,8 @@ gst_rtspsrc_change_state (GstElement * element, GstStateChange transition) ret = GST_STATE_CHANGE_NO_PREROLL; break; case GST_STATE_CHANGE_PAUSED_TO_READY: - gst_rtspsrc_loop_send_cmd (rtspsrc, CMD_CLOSE, CMD_ALL); + gst_rtspsrc_loop_send_cmd_and_wait (rtspsrc, CMD_CLOSE, CMD_ALL, + rtspsrc->teardown_timeout); ret = GST_STATE_CHANGE_SUCCESS; break; case GST_STATE_CHANGE_READY_TO_NULL: @@ -8327,3 +9551,526 @@ gst_rtspsrc_uri_handler_init (gpointer g_iface, gpointer iface_data) iface->get_uri = gst_rtspsrc_uri_get_uri; iface->set_uri = gst_rtspsrc_uri_set_uri; } + + +/* send GET_PARAMETER */ +static GstRTSPResult +gst_rtspsrc_get_parameter (GstRTSPSrc * src, ParameterRequest * req) +{ + GstRTSPMessage request = { 0 }; + GstRTSPMessage response = { 0 }; + GstRTSPResult res; + GstRTSPStatusCode code = GST_RTSP_STS_OK; + const gchar *control; + gchar *recv_body = NULL; + guint recv_body_len; + + GST_DEBUG_OBJECT (src, "creating server get_parameter"); + + if ((res = gst_rtspsrc_ensure_open (src, FALSE)) < 0) + goto open_failed; + + control = get_aggregate_control (src); + if (control == NULL) + goto no_control; + + if (!(src->methods & GST_RTSP_GET_PARAMETER)) + goto not_supported; + + gst_rtspsrc_connection_flush (src, FALSE); + + res = gst_rtsp_message_init_request (&request, GST_RTSP_GET_PARAMETER, + control); + if (res < 0) + goto create_request_failed; + + res = gst_rtsp_message_add_header (&request, GST_RTSP_HDR_CONTENT_TYPE, + req->content_type == NULL ? "text/parameters" : req->content_type); + if (res < 0) + goto add_content_hdr_failed; + + if (req->body && req->body->len) { + res = + gst_rtsp_message_set_body (&request, (guint8 *) req->body->str, + req->body->len); + if (res < 0) + goto set_body_failed; + } + + if ((res = gst_rtspsrc_send (src, &src->conninfo, + &request, &response, &code, NULL)) < 0) + goto send_error; + + res = gst_rtsp_message_get_body (&response, (guint8 **) & recv_body, + &recv_body_len); + if (res < 0) + goto get_body_failed; + +done: + { + gst_promise_reply (req->promise, + gst_structure_new ("get-parameter-reply", + "rtsp-result", G_TYPE_INT, res, + "rtsp-code", G_TYPE_INT, code, + "rtsp-reason", G_TYPE_STRING, gst_rtsp_status_as_text (code), + "body", G_TYPE_STRING, GST_STR_NULL (recv_body), NULL)); + free_param_data (req); + + + gst_rtsp_message_unset (&request); + gst_rtsp_message_unset (&response); + + return res; + } + + /* ERRORS */ +open_failed: + { + GST_DEBUG_OBJECT (src, "failed to open stream"); + goto done; + } +no_control: + { + GST_DEBUG_OBJECT (src, "no control url to send GET_PARAMETER"); + res = GST_RTSP_ERROR; + goto done; + } +not_supported: + { + GST_DEBUG_OBJECT (src, "GET_PARAMETER is not supported"); + res = GST_RTSP_ERROR; + goto done; + } +create_request_failed: + { + GST_DEBUG_OBJECT (src, "could not create GET_PARAMETER request"); + goto done; + } +add_content_hdr_failed: + { + GST_DEBUG_OBJECT (src, "could not add content header"); + goto done; + } +set_body_failed: + { + GST_DEBUG_OBJECT (src, "could not set body"); + goto done; + } +send_error: + { + gchar *str = gst_rtsp_strresult (res); + + GST_ELEMENT_WARNING (src, RESOURCE, WRITE, (NULL), + ("Could not send get-parameter. (%s)", str)); + g_free (str); + goto done; + } +get_body_failed: + { + GST_DEBUG_OBJECT (src, "could not get body"); + goto done; + } +} + +/* send SET_PARAMETER */ +static GstRTSPResult +gst_rtspsrc_set_parameter (GstRTSPSrc * src, ParameterRequest * req) +{ + GstRTSPMessage request = { 0 }; + GstRTSPMessage response = { 0 }; + GstRTSPResult res = GST_RTSP_OK; + GstRTSPStatusCode code = GST_RTSP_STS_OK; + const gchar *control; + + GST_DEBUG_OBJECT (src, "creating server set_parameter"); + + if ((res = gst_rtspsrc_ensure_open (src, FALSE)) < 0) + goto open_failed; + + control = get_aggregate_control (src); + if (control == NULL) + goto no_control; + + if (!(src->methods & GST_RTSP_SET_PARAMETER)) + goto not_supported; + + gst_rtspsrc_connection_flush (src, FALSE); + + res = + gst_rtsp_message_init_request (&request, GST_RTSP_SET_PARAMETER, control); + if (res < 0) + goto send_error; + + res = gst_rtsp_message_add_header (&request, GST_RTSP_HDR_CONTENT_TYPE, + req->content_type == NULL ? "text/parameters" : req->content_type); + if (res < 0) + goto add_content_hdr_failed; + + if (req->body && req->body->len) { + res = + gst_rtsp_message_set_body (&request, (guint8 *) req->body->str, + req->body->len); + + if (res < 0) + goto set_body_failed; + } + + if ((res = gst_rtspsrc_send (src, &src->conninfo, + &request, &response, &code, NULL)) < 0) + goto send_error; + +done: + { + gst_promise_reply (req->promise, gst_structure_new ("set-parameter-reply", + "rtsp-result", G_TYPE_INT, res, + "rtsp-code", G_TYPE_INT, code, + "rtsp-reason", G_TYPE_STRING, gst_rtsp_status_as_text (code), + NULL)); + free_param_data (req); + + gst_rtsp_message_unset (&request); + gst_rtsp_message_unset (&response); + + return res; + } + + /* ERRORS */ +open_failed: + { + GST_DEBUG_OBJECT (src, "failed to open stream"); + goto done; + } +no_control: + { + GST_DEBUG_OBJECT (src, "no control url to send SET_PARAMETER"); + res = GST_RTSP_ERROR; + goto done; + } +not_supported: + { + GST_DEBUG_OBJECT (src, "SET_PARAMETER is not supported"); + res = GST_RTSP_ERROR; + goto done; + } +add_content_hdr_failed: + { + GST_DEBUG_OBJECT (src, "could not add content header"); + goto done; + } +set_body_failed: + { + GST_DEBUG_OBJECT (src, "could not set body"); + goto done; + } +send_error: + { + gchar *str = gst_rtsp_strresult (res); + + GST_ELEMENT_WARNING (src, RESOURCE, WRITE, (NULL), + ("Could not send set-parameter. (%s)", str)); + g_free (str); + goto done; + } +} + +typedef struct _RTSPKeyValue +{ + GstRTSPHeaderField field; + gchar *value; + gchar *custom_key; /* custom header string (field is INVALID then) */ +} RTSPKeyValue; + +static void +key_value_foreach (GArray * array, GFunc func, gpointer user_data) +{ + guint i; + + g_return_if_fail (array != NULL); + + for (i = 0; i < array->len; i++) { + (*func) (&g_array_index (array, RTSPKeyValue, i), user_data); + } +} + +static void +dump_key_value (gpointer data, gpointer user_data G_GNUC_UNUSED) +{ + RTSPKeyValue *key_value = (RTSPKeyValue *) data; + GstRTSPSrc *src = GST_RTSPSRC (user_data); + const gchar *key_string; + + if (key_value->custom_key != NULL) + key_string = key_value->custom_key; + else + key_string = gst_rtsp_header_as_text (key_value->field); + + GST_LOG_OBJECT (src, " key: '%s', value: '%s'", key_string, + key_value->value); +} + +static void +gst_rtspsrc_print_rtsp_message (GstRTSPSrc * src, const GstRTSPMessage * msg) +{ + guint8 *data; + guint size; + GString *body_string = NULL; + + g_return_if_fail (src != NULL); + g_return_if_fail (msg != NULL); + + if (gst_debug_category_get_threshold (GST_CAT_DEFAULT) < GST_LEVEL_LOG) + return; + + GST_LOG_OBJECT (src, "--------------------------------------------"); + switch (msg->type) { + case GST_RTSP_MESSAGE_REQUEST: + GST_LOG_OBJECT (src, "RTSP request message %p", msg); + GST_LOG_OBJECT (src, " request line:"); + GST_LOG_OBJECT (src, " method: '%s'", + gst_rtsp_method_as_text (msg->type_data.request.method)); + GST_LOG_OBJECT (src, " uri: '%s'", msg->type_data.request.uri); + GST_LOG_OBJECT (src, " version: '%s'", + gst_rtsp_version_as_text (msg->type_data.request.version)); + GST_LOG_OBJECT (src, " headers:"); + key_value_foreach (msg->hdr_fields, dump_key_value, src); + GST_LOG_OBJECT (src, " body:"); + gst_rtsp_message_get_body (msg, &data, &size); + if (size > 0) { + body_string = g_string_new_len ((const gchar *) data, size); + GST_LOG_OBJECT (src, " %s(%d)", body_string->str, size); + g_string_free (body_string, TRUE); + body_string = NULL; + } + break; + case GST_RTSP_MESSAGE_RESPONSE: + GST_LOG_OBJECT (src, "RTSP response message %p", msg); + GST_LOG_OBJECT (src, " status line:"); + GST_LOG_OBJECT (src, " code: '%d'", msg->type_data.response.code); + GST_LOG_OBJECT (src, " reason: '%s'", msg->type_data.response.reason); + GST_LOG_OBJECT (src, " version: '%s", + gst_rtsp_version_as_text (msg->type_data.response.version)); + GST_LOG_OBJECT (src, " headers:"); + key_value_foreach (msg->hdr_fields, dump_key_value, src); + gst_rtsp_message_get_body (msg, &data, &size); + GST_LOG_OBJECT (src, " body: length %d", size); + if (size > 0) { + body_string = g_string_new_len ((const gchar *) data, size); + GST_LOG_OBJECT (src, " %s(%d)", body_string->str, size); + g_string_free (body_string, TRUE); + body_string = NULL; + } + break; + case GST_RTSP_MESSAGE_HTTP_REQUEST: + GST_LOG_OBJECT (src, "HTTP request message %p", msg); + GST_LOG_OBJECT (src, " request line:"); + GST_LOG_OBJECT (src, " method: '%s'", + gst_rtsp_method_as_text (msg->type_data.request.method)); + GST_LOG_OBJECT (src, " uri: '%s'", msg->type_data.request.uri); + GST_LOG_OBJECT (src, " version: '%s'", + gst_rtsp_version_as_text (msg->type_data.request.version)); + GST_LOG_OBJECT (src, " headers:"); + key_value_foreach (msg->hdr_fields, dump_key_value, src); + GST_LOG_OBJECT (src, " body:"); + gst_rtsp_message_get_body (msg, &data, &size); + if (size > 0) { + body_string = g_string_new_len ((const gchar *) data, size); + GST_LOG_OBJECT (src, " %s(%d)", body_string->str, size); + g_string_free (body_string, TRUE); + body_string = NULL; + } + break; + case GST_RTSP_MESSAGE_HTTP_RESPONSE: + GST_LOG_OBJECT (src, "HTTP response message %p", msg); + GST_LOG_OBJECT (src, " status line:"); + GST_LOG_OBJECT (src, " code: '%d'", msg->type_data.response.code); + GST_LOG_OBJECT (src, " reason: '%s'", msg->type_data.response.reason); + GST_LOG_OBJECT (src, " version: '%s'", + gst_rtsp_version_as_text (msg->type_data.response.version)); + GST_LOG_OBJECT (src, " headers:"); + key_value_foreach (msg->hdr_fields, dump_key_value, src); + gst_rtsp_message_get_body (msg, &data, &size); + GST_LOG_OBJECT (src, " body: length %d", size); + if (size > 0) { + body_string = g_string_new_len ((const gchar *) data, size); + GST_LOG_OBJECT (src, " %s(%d)", body_string->str, size); + g_string_free (body_string, TRUE); + body_string = NULL; + } + break; + case GST_RTSP_MESSAGE_DATA: + GST_LOG_OBJECT (src, "RTSP data message %p", msg); + GST_LOG_OBJECT (src, " channel: '%d'", msg->type_data.data.channel); + GST_LOG_OBJECT (src, " size: '%d'", msg->body_size); + gst_rtsp_message_get_body (msg, &data, &size); + if (size > 0) { + body_string = g_string_new_len ((const gchar *) data, size); + GST_LOG_OBJECT (src, " %s(%d)", body_string->str, size); + g_string_free (body_string, TRUE); + body_string = NULL; + } + break; + default: + GST_LOG_OBJECT (src, "unsupported message type %d", msg->type); + break; + } + GST_LOG_OBJECT (src, "--------------------------------------------"); +} + +static void +gst_rtspsrc_print_sdp_media (GstRTSPSrc * src, GstSDPMedia * media) +{ + GST_LOG_OBJECT (src, " media: '%s'", GST_STR_NULL (media->media)); + GST_LOG_OBJECT (src, " port: '%u'", media->port); + GST_LOG_OBJECT (src, " num_ports: '%u'", media->num_ports); + GST_LOG_OBJECT (src, " proto: '%s'", GST_STR_NULL (media->proto)); + if (media->fmts && media->fmts->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " formats:"); + for (i = 0; i < media->fmts->len; i++) { + GST_LOG_OBJECT (src, " format '%s'", g_array_index (media->fmts, + gchar *, i)); + } + } + GST_LOG_OBJECT (src, " information: '%s'", + GST_STR_NULL (media->information)); + if (media->connections && media->connections->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " connections:"); + for (i = 0; i < media->connections->len; i++) { + GstSDPConnection *conn = + &g_array_index (media->connections, GstSDPConnection, i); + + GST_LOG_OBJECT (src, " nettype: '%s'", + GST_STR_NULL (conn->nettype)); + GST_LOG_OBJECT (src, " addrtype: '%s'", + GST_STR_NULL (conn->addrtype)); + GST_LOG_OBJECT (src, " address: '%s'", + GST_STR_NULL (conn->address)); + GST_LOG_OBJECT (src, " ttl: '%u'", conn->ttl); + GST_LOG_OBJECT (src, " addr_number: '%u'", conn->addr_number); + } + } + if (media->bandwidths && media->bandwidths->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " bandwidths:"); + for (i = 0; i < media->bandwidths->len; i++) { + GstSDPBandwidth *bw = + &g_array_index (media->bandwidths, GstSDPBandwidth, i); + + GST_LOG_OBJECT (src, " type: '%s'", GST_STR_NULL (bw->bwtype)); + GST_LOG_OBJECT (src, " bandwidth: '%u'", bw->bandwidth); + } + } + GST_LOG_OBJECT (src, " key:"); + GST_LOG_OBJECT (src, " type: '%s'", GST_STR_NULL (media->key.type)); + GST_LOG_OBJECT (src, " data: '%s'", GST_STR_NULL (media->key.data)); + if (media->attributes && media->attributes->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " attributes:"); + for (i = 0; i < media->attributes->len; i++) { + GstSDPAttribute *attr = + &g_array_index (media->attributes, GstSDPAttribute, i); + + GST_LOG_OBJECT (src, " attribute '%s' : '%s'", attr->key, attr->value); + } + } +} + +void +gst_rtspsrc_print_sdp_message (GstRTSPSrc * src, const GstSDPMessage * msg) +{ + g_return_if_fail (src != NULL); + g_return_if_fail (msg != NULL); + + if (gst_debug_category_get_threshold (GST_CAT_DEFAULT) < GST_LEVEL_LOG) + return; + + GST_LOG_OBJECT (src, "--------------------------------------------"); + GST_LOG_OBJECT (src, "sdp packet %p:", msg); + GST_LOG_OBJECT (src, " version: '%s'", GST_STR_NULL (msg->version)); + GST_LOG_OBJECT (src, " origin:"); + GST_LOG_OBJECT (src, " username: '%s'", + GST_STR_NULL (msg->origin.username)); + GST_LOG_OBJECT (src, " sess_id: '%s'", + GST_STR_NULL (msg->origin.sess_id)); + GST_LOG_OBJECT (src, " sess_version: '%s'", + GST_STR_NULL (msg->origin.sess_version)); + GST_LOG_OBJECT (src, " nettype: '%s'", + GST_STR_NULL (msg->origin.nettype)); + GST_LOG_OBJECT (src, " addrtype: '%s'", + GST_STR_NULL (msg->origin.addrtype)); + GST_LOG_OBJECT (src, " addr: '%s'", GST_STR_NULL (msg->origin.addr)); + GST_LOG_OBJECT (src, " session_name: '%s'", + GST_STR_NULL (msg->session_name)); + GST_LOG_OBJECT (src, " information: '%s'", GST_STR_NULL (msg->information)); + GST_LOG_OBJECT (src, " uri: '%s'", GST_STR_NULL (msg->uri)); + + if (msg->emails && msg->emails->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " emails:"); + for (i = 0; i < msg->emails->len; i++) { + GST_LOG_OBJECT (src, " email '%s'", g_array_index (msg->emails, gchar *, + i)); + } + } + if (msg->phones && msg->phones->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " phones:"); + for (i = 0; i < msg->phones->len; i++) { + GST_LOG_OBJECT (src, " phone '%s'", g_array_index (msg->phones, gchar *, + i)); + } + } + GST_LOG_OBJECT (src, " connection:"); + GST_LOG_OBJECT (src, " nettype: '%s'", + GST_STR_NULL (msg->connection.nettype)); + GST_LOG_OBJECT (src, " addrtype: '%s'", + GST_STR_NULL (msg->connection.addrtype)); + GST_LOG_OBJECT (src, " address: '%s'", + GST_STR_NULL (msg->connection.address)); + GST_LOG_OBJECT (src, " ttl: '%u'", msg->connection.ttl); + GST_LOG_OBJECT (src, " addr_number: '%u'", msg->connection.addr_number); + if (msg->bandwidths && msg->bandwidths->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " bandwidths:"); + for (i = 0; i < msg->bandwidths->len; i++) { + GstSDPBandwidth *bw = + &g_array_index (msg->bandwidths, GstSDPBandwidth, i); + + GST_LOG_OBJECT (src, " type: '%s'", GST_STR_NULL (bw->bwtype)); + GST_LOG_OBJECT (src, " bandwidth: '%u'", bw->bandwidth); + } + } + GST_LOG_OBJECT (src, " key:"); + GST_LOG_OBJECT (src, " type: '%s'", GST_STR_NULL (msg->key.type)); + GST_LOG_OBJECT (src, " data: '%s'", GST_STR_NULL (msg->key.data)); + if (msg->attributes && msg->attributes->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " attributes:"); + for (i = 0; i < msg->attributes->len; i++) { + GstSDPAttribute *attr = + &g_array_index (msg->attributes, GstSDPAttribute, i); + + GST_LOG_OBJECT (src, " attribute '%s' : '%s'", attr->key, attr->value); + } + } + if (msg->medias && msg->medias->len > 0) { + guint i; + + GST_LOG_OBJECT (src, " medias:"); + for (i = 0; i < msg->medias->len; i++) { + GST_LOG_OBJECT (src, " media %u:", i); + gst_rtspsrc_print_sdp_media (src, &g_array_index (msg->medias, + GstSDPMedia, i)); + } + } + GST_LOG_OBJECT (src, "--------------------------------------------"); +}