X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Frtsp%2Fgstrtspsrc.c;fp=gst%2Frtsp%2Fgstrtspsrc.c;h=390fb6f8eb38dba50f4d5b675f39163af9173040;hb=f05e14ba316d67b9cdf1440d9b2129da03625a30;hp=cc97bf75f2c18201dc9315c4e7e9ba4fdf913a63;hpb=ce0723527aa37d5f4d19ef8021c0b2eb8f83b08d;p=platform%2Fupstream%2Fgst-plugins-good.git diff --git a/gst/rtsp/gstrtspsrc.c b/gst/rtsp/gstrtspsrc.c index cc97bf7..390fb6f 100644 --- a/gst/rtsp/gstrtspsrc.c +++ b/gst/rtsp/gstrtspsrc.c @@ -281,6 +281,10 @@ gst_rtsp_backchannel_get_type (void) #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 { PROP_0, @@ -289,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, @@ -495,6 +503,32 @@ cmd_to_string (guint cmd) } #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) { @@ -582,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)", @@ -1300,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; @@ -1337,6 +1390,10 @@ gst_rtspsrc_init (GstRTSPSrc * src) 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 (); @@ -1390,6 +1447,22 @@ gst_rtspsrc_finalize (GObject * object) 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); @@ -1399,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; @@ -1535,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; @@ -1704,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; @@ -2074,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); @@ -2093,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 */ @@ -2567,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); @@ -5556,8 +5704,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); @@ -5567,8 +5720,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; @@ -5688,8 +5846,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 { @@ -5701,8 +5864,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; } @@ -5713,8 +5881,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 { @@ -5786,10 +5960,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: @@ -5836,9 +6015,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")); @@ -5897,6 +6105,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")); @@ -6228,8 +6444,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: @@ -6316,8 +6537,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"); } @@ -6396,8 +6623,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"); } @@ -6511,12 +6743,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: @@ -6560,8 +6802,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 */ @@ -6644,14 +6891,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; } } @@ -7391,39 +7648,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; } @@ -7432,8 +7716,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"); } @@ -7444,15 +7733,27 @@ 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; } @@ -7503,10 +7804,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 @@ -7681,6 +7993,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++) { @@ -7688,7 +8005,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; @@ -7708,6 +8033,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 @@ -7859,8 +8195,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: @@ -7868,8 +8209,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"); } @@ -7880,8 +8226,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; } @@ -7899,15 +8250,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; } @@ -8060,8 +8421,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; } @@ -8071,8 +8437,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"); } @@ -8212,7 +8583,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 { @@ -8223,6 +8599,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); } @@ -8338,13 +8717,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]; @@ -8504,8 +8904,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; } @@ -8515,8 +8920,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"); } @@ -8633,8 +9043,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; } @@ -8644,8 +9059,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"); } @@ -8877,8 +9297,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: @@ -8919,6 +9345,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: