rtspsrc: implement more async handling
[gstreamer-omap:gst-plugins-good.git] / gst / rtsp / gstrtspsrc.c
1 /* GStreamer
2  * Copyright (C) <2005,2006> Wim Taymans <wim at fluendo dot com>
3  *               <2006> Lutz Mueller <lutz at topfrose dot de>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public
16  * License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18  * Boston, MA 02111-1307, USA.
19  */
20 /*
21  * Unless otherwise indicated, Source Code is licensed under MIT license.
22  * See further explanation attached in License Statement (distributed in the file
23  * LICENSE).
24  *
25  * Permission is hereby granted, free of charge, to any person obtaining a copy of
26  * this software and associated documentation files (the "Software"), to deal in
27  * the Software without restriction, including without limitation the rights to
28  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
29  * of the Software, and to permit persons to whom the Software is furnished to do
30  * so, subject to the following conditions:
31  *
32  * The above copyright notice and this permission notice shall be included in all
33  * copies or substantial portions of the Software.
34  *
35  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
36  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
37  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
38  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
39  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
40  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
41  * SOFTWARE.
42  */
43 /**
44  * SECTION:element-rtspsrc
45  *
46  * Makes a connection to an RTSP server and read the data.
47  * rtspsrc strictly follows RFC 2326 and therefore does not (yet) support
48  * RealMedia/Quicktime/Microsoft extensions.
49  *
50  * RTSP supports transport over TCP or UDP in unicast or multicast mode. By
51  * default rtspsrc will negotiate a connection in the following order:
52  * UDP unicast/UDP multicast/TCP. The order cannot be changed but the allowed
53  * protocols can be controlled with the #GstRTSPSrc:protocols property.
54  *
55  * rtspsrc currently understands SDP as the format of the session description.
56  * For each stream listed in the SDP a new rtp_stream%d pad will be created
57  * with caps derived from the SDP media description. This is a caps of mime type
58  * "application/x-rtp" that can be connected to any available RTP depayloader
59  * element.
60  *
61  * rtspsrc will internally instantiate an RTP session manager element
62  * that will handle the RTCP messages to and from the server, jitter removal,
63  * packet reordering along with providing a clock for the pipeline.
64  * This feature is implemented using the gstrtpbin element.
65  *
66  * rtspsrc acts like a live source and will therefore only generate data in the
67  * PLAYING state.
68  *
69  * <refsect2>
70  * <title>Example launch line</title>
71  * |[
72  * gst-launch rtspsrc location=rtsp://some.server/url ! fakesink
73  * ]| Establish a connection to an RTSP server and send the raw RTP packets to a
74  * fakesink.
75  * </refsect2>
76  *
77  * Last reviewed on 2006-08-18 (0.10.5)
78  */
79
80 #ifdef HAVE_CONFIG_H
81 #include "config.h"
82 #endif
83
84 #ifdef HAVE_UNISTD_H
85 #include <unistd.h>
86 #endif /* HAVE_UNISTD_H */
87 #include <stdlib.h>
88 #include <string.h>
89 #include <locale.h>
90 #include <stdio.h>
91 #include <stdarg.h>
92
93 #include <gst/sdp/gstsdpmessage.h>
94 #include <gst/rtp/gstrtppayloads.h>
95
96 #include "gst/gst-i18n-plugin.h"
97
98 #include "gstrtspsrc.h"
99
100 #ifdef G_OS_WIN32
101 #include <winsock2.h>
102 #endif
103
104 GST_DEBUG_CATEGORY_STATIC (rtspsrc_debug);
105 #define GST_CAT_DEFAULT (rtspsrc_debug)
106
107 static GstStaticPadTemplate rtptemplate = GST_STATIC_PAD_TEMPLATE ("stream%d",
108     GST_PAD_SRC,
109     GST_PAD_SOMETIMES,
110     GST_STATIC_CAPS ("application/x-rtp; application/x-rdt"));
111
112 /* templates used internally */
113 static GstStaticPadTemplate anysrctemplate =
114 GST_STATIC_PAD_TEMPLATE ("internalsrc%d",
115     GST_PAD_SRC,
116     GST_PAD_SOMETIMES,
117     GST_STATIC_CAPS_ANY);
118
119 static GstStaticPadTemplate anysinktemplate =
120 GST_STATIC_PAD_TEMPLATE ("internalsink%d",
121     GST_PAD_SINK,
122     GST_PAD_SOMETIMES,
123     GST_STATIC_CAPS_ANY);
124
125 enum
126 {
127   /* FILL ME */
128   LAST_SIGNAL
129 };
130
131 enum _GstRtspSrcBufferMode
132 {
133   BUFFER_MODE_NONE,
134   BUFFER_MODE_SLAVE,
135   BUFFER_MODE_BUFFER,
136   BUFFER_MODE_AUTO
137 };
138
139 #define GST_TYPE_RTSP_SRC_BUFFER_MODE (gst_rtsp_src_buffer_mode_get_type())
140 static GType
141 gst_rtsp_src_buffer_mode_get_type (void)
142 {
143   static GType buffer_mode_type = 0;
144   static const GEnumValue buffer_modes[] = {
145     {BUFFER_MODE_NONE, "Only use RTP timestamps", "none"},
146     {BUFFER_MODE_SLAVE, "Slave receiver to sender clock", "slave"},
147     {BUFFER_MODE_BUFFER, "Do low/high watermark buffering", "buffer"},
148     {BUFFER_MODE_AUTO, "Choose mode depending on stream live", "auto"},
149     {0, NULL, NULL},
150   };
151
152   if (!buffer_mode_type) {
153     buffer_mode_type =
154         g_enum_register_static ("GstRTSPSrcBufferMode", buffer_modes);
155   }
156   return buffer_mode_type;
157 }
158
159 #define DEFAULT_LOCATION         NULL
160 #define DEFAULT_PROTOCOLS        GST_RTSP_LOWER_TRANS_UDP | GST_RTSP_LOWER_TRANS_UDP_MCAST | GST_RTSP_LOWER_TRANS_TCP
161 #define DEFAULT_DEBUG            FALSE
162 #define DEFAULT_RETRY            20
163 #define DEFAULT_TIMEOUT          5000000
164 #define DEFAULT_UDP_BUFFER_SIZE  0x80000
165 #define DEFAULT_TCP_TIMEOUT      20000000
166 #define DEFAULT_LATENCY_MS       2000
167 #define DEFAULT_CONNECTION_SPEED 0
168 #define DEFAULT_NAT_METHOD       GST_RTSP_NAT_DUMMY
169 #define DEFAULT_DO_RTCP          TRUE
170 #define DEFAULT_PROXY            NULL
171 #define DEFAULT_RTP_BLOCKSIZE    0
172 #define DEFAULT_USER_ID          NULL
173 #define DEFAULT_USER_PW          NULL
174 #define DEFAULT_BUFFER_MODE      BUFFER_MODE_AUTO
175 #define DEFAULT_PORT_RANGE       NULL
176
177 enum
178 {
179   PROP_0,
180   PROP_LOCATION,
181   PROP_PROTOCOLS,
182   PROP_DEBUG,
183   PROP_RETRY,
184   PROP_TIMEOUT,
185   PROP_TCP_TIMEOUT,
186   PROP_LATENCY,
187   PROP_CONNECTION_SPEED,
188   PROP_NAT_METHOD,
189   PROP_DO_RTCP,
190   PROP_PROXY,
191   PROP_RTP_BLOCKSIZE,
192   PROP_USER_ID,
193   PROP_USER_PW,
194   PROP_BUFFER_MODE,
195   PROP_PORT_RANGE,
196   PROP_UDP_BUFFER_SIZE,
197   PROP_LAST
198 };
199
200 #define GST_TYPE_RTSP_NAT_METHOD (gst_rtsp_nat_method_get_type())
201 static GType
202 gst_rtsp_nat_method_get_type (void)
203 {
204   static GType rtsp_nat_method_type = 0;
205   static const GEnumValue rtsp_nat_method[] = {
206     {GST_RTSP_NAT_NONE, "None", "none"},
207     {GST_RTSP_NAT_DUMMY, "Send Dummy packets", "dummy"},
208     {0, NULL, NULL},
209   };
210
211   if (!rtsp_nat_method_type) {
212     rtsp_nat_method_type =
213         g_enum_register_static ("GstRTSPNatMethod", rtsp_nat_method);
214   }
215   return rtsp_nat_method_type;
216 }
217
218 static void gst_rtspsrc_finalize (GObject * object);
219
220 static void gst_rtspsrc_set_property (GObject * object, guint prop_id,
221     const GValue * value, GParamSpec * pspec);
222 static void gst_rtspsrc_get_property (GObject * object, guint prop_id,
223     GValue * value, GParamSpec * pspec);
224
225 static void gst_rtspsrc_uri_handler_init (gpointer g_iface,
226     gpointer iface_data);
227
228 static void gst_rtspsrc_sdp_attributes_to_caps (GArray * attributes,
229     GstCaps * caps);
230
231 static gboolean gst_rtspsrc_set_proxy (GstRTSPSrc * rtsp, const gchar * proxy);
232 static void gst_rtspsrc_set_tcp_timeout (GstRTSPSrc * rtspsrc, guint64 timeout);
233
234 static GstCaps *gst_rtspsrc_media_to_caps (gint pt, const GstSDPMedia * media);
235
236 static GstStateChangeReturn gst_rtspsrc_change_state (GstElement * element,
237     GstStateChange transition);
238 static gboolean gst_rtspsrc_send_event (GstElement * element, GstEvent * event);
239 static void gst_rtspsrc_handle_message (GstBin * bin, GstMessage * message);
240
241 static gboolean gst_rtspsrc_setup_auth (GstRTSPSrc * src,
242     GstRTSPMessage * response);
243
244 static void gst_rtspsrc_loop_send_cmd (GstRTSPSrc * src, gint cmd,
245     gboolean flush);
246 static GstRTSPResult gst_rtspsrc_send_cb (GstRTSPExtension * ext,
247     GstRTSPMessage * request, GstRTSPMessage * response, GstRTSPSrc * src);
248
249 static GstRTSPResult gst_rtspsrc_open (GstRTSPSrc * src, gboolean async);
250 static GstRTSPResult gst_rtspsrc_play (GstRTSPSrc * src, GstSegment * segment,
251     gboolean async);
252 static GstRTSPResult gst_rtspsrc_pause (GstRTSPSrc * src, gboolean idle,
253     gboolean async);
254 static GstRTSPResult gst_rtspsrc_close (GstRTSPSrc * src, gboolean async);
255
256 static gboolean gst_rtspsrc_uri_set_uri (GstURIHandler * handler,
257     const gchar * uri);
258
259 static gboolean gst_rtspsrc_activate_streams (GstRTSPSrc * src);
260 static gboolean gst_rtspsrc_loop (GstRTSPSrc * src);
261 static gboolean gst_rtspsrc_stream_push_event (GstRTSPSrc * src,
262     GstRTSPStream * stream, GstEvent * event, gboolean source);
263 static gboolean gst_rtspsrc_push_event (GstRTSPSrc * src, GstEvent * event,
264     gboolean source);
265
266 /* commands we send to out loop to notify it of events */
267 #define CMD_OPEN        0
268 #define CMD_PLAY        1
269 #define CMD_PAUSE       2
270 #define CMD_CLOSE       3
271 #define CMD_WAIT        4
272 #define CMD_RECONNECT   5
273 #define CMD_LOOP        6
274
275 #define GST_ELEMENT_PROGRESS(el, type, code, text)      \
276 G_STMT_START {                                          \
277   gchar *__txt = _gst_element_error_printf text;        \
278   gst_element_post_message (GST_ELEMENT_CAST (el),      \
279       gst_message_new_progress (GST_OBJECT_CAST (el),   \
280           GST_PROGRESS_TYPE_ ##type, code, __txt));     \
281   g_free (__txt);                                       \
282 } G_STMT_END
283
284 /*static guint gst_rtspsrc_signals[LAST_SIGNAL] = { 0 }; */
285
286 static void
287 _do_init (GType rtspsrc_type)
288 {
289   static const GInterfaceInfo urihandler_info = {
290     gst_rtspsrc_uri_handler_init,
291     NULL,
292     NULL
293   };
294
295   GST_DEBUG_CATEGORY_INIT (rtspsrc_debug, "rtspsrc", 0, "RTSP src");
296
297   g_type_add_interface_static (rtspsrc_type, GST_TYPE_URI_HANDLER,
298       &urihandler_info);
299 }
300
301 GST_BOILERPLATE_FULL (GstRTSPSrc, gst_rtspsrc, GstBin, GST_TYPE_BIN, _do_init);
302
303 static void
304 gst_rtspsrc_base_init (gpointer g_class)
305 {
306   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
307
308   gst_element_class_add_pad_template (element_class,
309       gst_static_pad_template_get (&rtptemplate));
310
311   gst_element_class_set_details_simple (element_class, "RTSP packet receiver",
312       "Source/Network",
313       "Receive data over the network via RTSP (RFC 2326)",
314       "Wim Taymans <wim@fluendo.com>, "
315       "Thijs Vermeir <thijs.vermeir@barco.com>, "
316       "Lutz Mueller <lutz@topfrose.de>");
317 }
318
319 static void
320 gst_rtspsrc_class_init (GstRTSPSrcClass * klass)
321 {
322   GObjectClass *gobject_class;
323   GstElementClass *gstelement_class;
324   GstBinClass *gstbin_class;
325
326   gobject_class = (GObjectClass *) klass;
327   gstelement_class = (GstElementClass *) klass;
328   gstbin_class = (GstBinClass *) klass;
329
330   gobject_class->set_property = gst_rtspsrc_set_property;
331   gobject_class->get_property = gst_rtspsrc_get_property;
332
333   gobject_class->finalize = gst_rtspsrc_finalize;
334
335   g_object_class_install_property (gobject_class, PROP_LOCATION,
336       g_param_spec_string ("location", "RTSP Location",
337           "Location of the RTSP url to read",
338           DEFAULT_LOCATION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
339
340   g_object_class_install_property (gobject_class, PROP_PROTOCOLS,
341       g_param_spec_flags ("protocols", "Protocols",
342           "Allowed lower transport protocols", GST_TYPE_RTSP_LOWER_TRANS,
343           DEFAULT_PROTOCOLS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
344
345   g_object_class_install_property (gobject_class, PROP_DEBUG,
346       g_param_spec_boolean ("debug", "Debug",
347           "Dump request and response messages to stdout",
348           DEFAULT_DEBUG, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
349
350   g_object_class_install_property (gobject_class, PROP_RETRY,
351       g_param_spec_uint ("retry", "Retry",
352           "Max number of retries when allocating RTP ports.",
353           0, G_MAXUINT16, DEFAULT_RETRY,
354           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
355
356   g_object_class_install_property (gobject_class, PROP_TIMEOUT,
357       g_param_spec_uint64 ("timeout", "Timeout",
358           "Retry TCP transport after UDP timeout microseconds (0 = disabled)",
359           0, G_MAXUINT64, DEFAULT_TIMEOUT,
360           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
361
362   g_object_class_install_property (gobject_class, PROP_TCP_TIMEOUT,
363       g_param_spec_uint64 ("tcp-timeout", "TCP Timeout",
364           "Fail after timeout microseconds on TCP connections (0 = disabled)",
365           0, G_MAXUINT64, DEFAULT_TCP_TIMEOUT,
366           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
367
368   g_object_class_install_property (gobject_class, PROP_LATENCY,
369       g_param_spec_uint ("latency", "Buffer latency in ms",
370           "Amount of ms to buffer", 0, G_MAXUINT, DEFAULT_LATENCY_MS,
371           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
372
373   g_object_class_install_property (gobject_class, PROP_CONNECTION_SPEED,
374       g_param_spec_uint ("connection-speed", "Connection Speed",
375           "Network connection speed in kbps (0 = unknown)",
376           0, G_MAXINT / 1000, DEFAULT_CONNECTION_SPEED,
377           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
378
379   g_object_class_install_property (gobject_class, PROP_NAT_METHOD,
380       g_param_spec_enum ("nat-method", "NAT Method",
381           "Method to use for traversing firewalls and NAT",
382           GST_TYPE_RTSP_NAT_METHOD, DEFAULT_NAT_METHOD,
383           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
384
385   /**
386    * GstRTSPSrc::do-rtcp
387    *
388    * Enable RTCP support. Some old server don't like RTCP and then this property
389    * needs to be set to FALSE.
390    *
391    * Since: 0.10.15
392    */
393   g_object_class_install_property (gobject_class, PROP_DO_RTCP,
394       g_param_spec_boolean ("do-rtcp", "Do RTCP",
395           "Send RTCP packets, disable for old incompatible server.",
396           DEFAULT_DO_RTCP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
397
398   /**
399    * GstRTSPSrc::proxy
400    *
401    * Set the proxy parameters. This has to be a string of the format
402    * [http://][user:passwd@]host[:port].
403    *
404    * Since: 0.10.15
405    */
406   g_object_class_install_property (gobject_class, PROP_PROXY,
407       g_param_spec_string ("proxy", "Proxy",
408           "Proxy settings for HTTP tunneling. Format: [http://][user:passwd@]host[:port]",
409           DEFAULT_PROXY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
410
411   /**
412    * GstRTSPSrc::rtp_blocksize
413    *
414    * RTP package size to suggest to server.
415    *
416    * Since: 0.10.16
417    */
418   g_object_class_install_property (gobject_class, PROP_RTP_BLOCKSIZE,
419       g_param_spec_uint ("rtp-blocksize", "RTP Blocksize",
420           "RTP package size to suggest to server (0 = disabled)",
421           0, 65536, DEFAULT_RTP_BLOCKSIZE,
422           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
423
424   g_object_class_install_property (gobject_class,
425       PROP_USER_ID,
426       g_param_spec_string ("user-id", "user-id",
427           "RTSP location URI user id for authentication", DEFAULT_USER_ID,
428           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
429   g_object_class_install_property (gobject_class, PROP_USER_PW,
430       g_param_spec_string ("user-pw", "user-pw",
431           "RTSP location URI user password for authentication", DEFAULT_USER_PW,
432           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
433
434   /**
435    * GstRTSPSrc::buffer-mode:
436    *
437    * Control the buffering and timestamping mode used by the jitterbuffer.
438    *
439    * Since: 0.10.22
440    */
441   g_object_class_install_property (gobject_class, PROP_BUFFER_MODE,
442       g_param_spec_enum ("buffer-mode", "Buffer Mode",
443           "Control the buffering algorithm in use",
444           GST_TYPE_RTSP_SRC_BUFFER_MODE, DEFAULT_BUFFER_MODE,
445           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
446
447   /**
448    * GstRTSPSrc::port-range:
449    *
450    * Configure the client port numbers that can be used to recieve RTP and
451    * RTCP.
452    *
453    * Since: 0.10.25
454    */
455   g_object_class_install_property (gobject_class, PROP_PORT_RANGE,
456       g_param_spec_string ("port-range", "Port range",
457           "Client port range that can be used to receive RTP and RTCP data, "
458           "eg. 3000-3005 (NULL = no restrictions)", DEFAULT_PORT_RANGE,
459           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
460
461   /**
462    * GstRTSPSrc::udp-buffer-size:
463    *
464    * Size of the kernel UDP receive buffer in bytes.
465    *
466    * Since: 0.10.26
467    */
468   g_object_class_install_property (gobject_class, PROP_UDP_BUFFER_SIZE,
469       g_param_spec_int ("udp-buffer-size", "UDP Buffer Size",
470           "Size of the kernel UDP receive buffer in bytes, 0=default",
471           0, G_MAXINT, DEFAULT_UDP_BUFFER_SIZE,
472           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
473
474   gstelement_class->send_event = gst_rtspsrc_send_event;
475   gstelement_class->change_state = gst_rtspsrc_change_state;
476
477   gstbin_class->handle_message = gst_rtspsrc_handle_message;
478
479   gst_rtsp_ext_list_init ();
480 }
481
482
483 static void
484 gst_rtspsrc_init (GstRTSPSrc * src, GstRTSPSrcClass * g_class)
485 {
486 #ifdef G_OS_WIN32
487   WSADATA wsa_data;
488
489   if (WSAStartup (MAKEWORD (2, 2), &wsa_data) != 0) {
490     GST_ERROR_OBJECT (src, "WSAStartup failed: 0x%08x", WSAGetLastError ());
491   }
492 #endif
493
494   src->conninfo.location = g_strdup (DEFAULT_LOCATION);
495   src->protocols = DEFAULT_PROTOCOLS;
496   src->debug = DEFAULT_DEBUG;
497   src->retry = DEFAULT_RETRY;
498   src->udp_timeout = DEFAULT_TIMEOUT;
499   gst_rtspsrc_set_tcp_timeout (src, DEFAULT_TCP_TIMEOUT);
500   src->latency = DEFAULT_LATENCY_MS;
501   src->connection_speed = DEFAULT_CONNECTION_SPEED;
502   src->nat_method = DEFAULT_NAT_METHOD;
503   src->do_rtcp = DEFAULT_DO_RTCP;
504   gst_rtspsrc_set_proxy (src, DEFAULT_PROXY);
505   src->rtp_blocksize = DEFAULT_RTP_BLOCKSIZE;
506   src->user_id = g_strdup (DEFAULT_USER_ID);
507   src->user_pw = g_strdup (DEFAULT_USER_PW);
508   src->buffer_mode = DEFAULT_BUFFER_MODE;
509   src->client_port_range.min = 0;
510   src->client_port_range.max = 0;
511   src->udp_buffer_size = DEFAULT_UDP_BUFFER_SIZE;
512
513   /* get a list of all extensions */
514   src->extensions = gst_rtsp_ext_list_get ();
515
516   /* connect to send signal */
517   gst_rtsp_ext_list_connect (src->extensions, "send",
518       (GCallback) gst_rtspsrc_send_cb, src);
519
520   /* protects the streaming thread in interleaved mode or the polling
521    * thread in UDP mode. */
522   src->stream_rec_lock = g_new (GStaticRecMutex, 1);
523   g_static_rec_mutex_init (src->stream_rec_lock);
524
525   /* protects our state changes from multiple invocations */
526   src->state_rec_lock = g_new (GStaticRecMutex, 1);
527   g_static_rec_mutex_init (src->state_rec_lock);
528
529   src->state = GST_RTSP_STATE_INVALID;
530 }
531
532 static void
533 gst_rtspsrc_finalize (GObject * object)
534 {
535   GstRTSPSrc *rtspsrc;
536
537   rtspsrc = GST_RTSPSRC (object);
538
539   gst_rtsp_ext_list_free (rtspsrc->extensions);
540   g_free (rtspsrc->conninfo.location);
541   gst_rtsp_url_free (rtspsrc->conninfo.url);
542   g_free (rtspsrc->conninfo.url_str);
543   g_free (rtspsrc->user_id);
544   g_free (rtspsrc->user_pw);
545
546   if (rtspsrc->sdp) {
547     gst_sdp_message_free (rtspsrc->sdp);
548     rtspsrc->sdp = NULL;
549   }
550
551   /* free locks */
552   g_static_rec_mutex_free (rtspsrc->stream_rec_lock);
553   g_free (rtspsrc->stream_rec_lock);
554   g_static_rec_mutex_free (rtspsrc->state_rec_lock);
555   g_free (rtspsrc->state_rec_lock);
556
557 #ifdef G_OS_WIN32
558   WSACleanup ();
559 #endif
560
561   G_OBJECT_CLASS (parent_class)->finalize (object);
562 }
563
564 /* a proxy string of the format [user:passwd@]host[:port] */
565 static gboolean
566 gst_rtspsrc_set_proxy (GstRTSPSrc * rtsp, const gchar * proxy)
567 {
568   gchar *p, *at, *col;
569
570   g_free (rtsp->proxy_user);
571   rtsp->proxy_user = NULL;
572   g_free (rtsp->proxy_passwd);
573   rtsp->proxy_passwd = NULL;
574   g_free (rtsp->proxy_host);
575   rtsp->proxy_host = NULL;
576   rtsp->proxy_port = 0;
577
578   p = (gchar *) proxy;
579
580   if (p == NULL)
581     return TRUE;
582
583   /* we allow http:// in front but ignore it */
584   if (g_str_has_prefix (p, "http://"))
585     p += 7;
586
587   at = strchr (p, '@');
588   if (at) {
589     /* look for user:passwd */
590     col = strchr (proxy, ':');
591     if (col == NULL || col > at)
592       return FALSE;
593
594     rtsp->proxy_user = g_strndup (p, col - p);
595     col++;
596     rtsp->proxy_passwd = g_strndup (col, at - col);
597
598     /* move to host */
599     p = at + 1;
600   }
601   col = strchr (p, ':');
602
603   if (col) {
604     /* everything before the colon is the hostname */
605     rtsp->proxy_host = g_strndup (p, col - p);
606     p = col + 1;
607     rtsp->proxy_port = strtoul (p, (char **) &p, 10);
608   } else {
609     rtsp->proxy_host = g_strdup (p);
610     rtsp->proxy_port = 8080;
611   }
612   return TRUE;
613 }
614
615 static void
616 gst_rtspsrc_set_tcp_timeout (GstRTSPSrc * rtspsrc, guint64 timeout)
617 {
618   rtspsrc->tcp_timeout.tv_sec = timeout / G_USEC_PER_SEC;
619   rtspsrc->tcp_timeout.tv_usec = timeout % G_USEC_PER_SEC;
620
621   if (timeout != 0)
622     rtspsrc->ptcp_timeout = &rtspsrc->tcp_timeout;
623   else
624     rtspsrc->ptcp_timeout = NULL;
625 }
626
627 static void
628 gst_rtspsrc_set_property (GObject * object, guint prop_id, const GValue * value,
629     GParamSpec * pspec)
630 {
631   GstRTSPSrc *rtspsrc;
632
633   rtspsrc = GST_RTSPSRC (object);
634
635   switch (prop_id) {
636     case PROP_LOCATION:
637       gst_rtspsrc_uri_set_uri (GST_URI_HANDLER (rtspsrc),
638           g_value_get_string (value));
639       break;
640     case PROP_PROTOCOLS:
641       rtspsrc->protocols = g_value_get_flags (value);
642       break;
643     case PROP_DEBUG:
644       rtspsrc->debug = g_value_get_boolean (value);
645       break;
646     case PROP_RETRY:
647       rtspsrc->retry = g_value_get_uint (value);
648       break;
649     case PROP_TIMEOUT:
650       rtspsrc->udp_timeout = g_value_get_uint64 (value);
651       break;
652     case PROP_TCP_TIMEOUT:
653       gst_rtspsrc_set_tcp_timeout (rtspsrc, g_value_get_uint64 (value));
654       break;
655     case PROP_LATENCY:
656       rtspsrc->latency = g_value_get_uint (value);
657       break;
658     case PROP_CONNECTION_SPEED:
659       rtspsrc->connection_speed = g_value_get_uint (value);
660       break;
661     case PROP_NAT_METHOD:
662       rtspsrc->nat_method = g_value_get_enum (value);
663       break;
664     case PROP_DO_RTCP:
665       rtspsrc->do_rtcp = g_value_get_boolean (value);
666       break;
667     case PROP_PROXY:
668       gst_rtspsrc_set_proxy (rtspsrc, g_value_get_string (value));
669       break;
670     case PROP_RTP_BLOCKSIZE:
671       rtspsrc->rtp_blocksize = g_value_get_uint (value);
672       break;
673     case PROP_USER_ID:
674       if (rtspsrc->user_id)
675         g_free (rtspsrc->user_id);
676       rtspsrc->user_id = g_value_dup_string (value);
677       break;
678     case PROP_USER_PW:
679       if (rtspsrc->user_pw)
680         g_free (rtspsrc->user_pw);
681       rtspsrc->user_pw = g_value_dup_string (value);
682       break;
683     case PROP_BUFFER_MODE:
684       rtspsrc->buffer_mode = g_value_get_enum (value);
685       break;
686     case PROP_PORT_RANGE:
687     {
688       const gchar *str;
689
690       str = g_value_get_string (value);
691       if (str) {
692         sscanf (str, "%u-%u",
693             &rtspsrc->client_port_range.min, &rtspsrc->client_port_range.max);
694       } else {
695         rtspsrc->client_port_range.min = 0;
696         rtspsrc->client_port_range.max = 0;
697       }
698       break;
699     }
700     case PROP_UDP_BUFFER_SIZE:
701       rtspsrc->udp_buffer_size = g_value_get_int (value);
702       break;
703     default:
704       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
705       break;
706   }
707 }
708
709 static void
710 gst_rtspsrc_get_property (GObject * object, guint prop_id, GValue * value,
711     GParamSpec * pspec)
712 {
713   GstRTSPSrc *rtspsrc;
714
715   rtspsrc = GST_RTSPSRC (object);
716
717   switch (prop_id) {
718     case PROP_LOCATION:
719       g_value_set_string (value, rtspsrc->conninfo.location);
720       break;
721     case PROP_PROTOCOLS:
722       g_value_set_flags (value, rtspsrc->protocols);
723       break;
724     case PROP_DEBUG:
725       g_value_set_boolean (value, rtspsrc->debug);
726       break;
727     case PROP_RETRY:
728       g_value_set_uint (value, rtspsrc->retry);
729       break;
730     case PROP_TIMEOUT:
731       g_value_set_uint64 (value, rtspsrc->udp_timeout);
732       break;
733     case PROP_TCP_TIMEOUT:
734     {
735       guint64 timeout;
736
737       timeout = rtspsrc->tcp_timeout.tv_sec * G_USEC_PER_SEC +
738           rtspsrc->tcp_timeout.tv_usec;
739       g_value_set_uint64 (value, timeout);
740       break;
741     }
742     case PROP_LATENCY:
743       g_value_set_uint (value, rtspsrc->latency);
744       break;
745     case PROP_CONNECTION_SPEED:
746       g_value_set_uint (value, rtspsrc->connection_speed);
747       break;
748     case PROP_NAT_METHOD:
749       g_value_set_enum (value, rtspsrc->nat_method);
750       break;
751     case PROP_DO_RTCP:
752       g_value_set_boolean (value, rtspsrc->do_rtcp);
753       break;
754     case PROP_PROXY:
755     {
756       gchar *str;
757
758       if (rtspsrc->proxy_host) {
759         str =
760             g_strdup_printf ("%s:%d", rtspsrc->proxy_host, rtspsrc->proxy_port);
761       } else {
762         str = NULL;
763       }
764       g_value_take_string (value, str);
765       break;
766     }
767     case PROP_RTP_BLOCKSIZE:
768       g_value_set_uint (value, rtspsrc->rtp_blocksize);
769       break;
770     case PROP_USER_ID:
771       g_value_set_string (value, rtspsrc->user_id);
772       break;
773     case PROP_USER_PW:
774       g_value_set_string (value, rtspsrc->user_pw);
775       break;
776     case PROP_BUFFER_MODE:
777       g_value_set_enum (value, rtspsrc->buffer_mode);
778       break;
779     case PROP_PORT_RANGE:
780     {
781       gchar *str;
782
783       if (rtspsrc->client_port_range.min != 0) {
784         str = g_strdup_printf ("%u-%u", rtspsrc->client_port_range.min,
785             rtspsrc->client_port_range.max);
786       } else {
787         str = NULL;
788       }
789       g_value_take_string (value, str);
790       break;
791     }
792     case PROP_UDP_BUFFER_SIZE:
793       g_value_set_int (value, rtspsrc->udp_buffer_size);
794       break;
795     default:
796       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
797       break;
798   }
799 }
800
801 static gint
802 find_stream_by_id (GstRTSPStream * stream, gint * id)
803 {
804   if (stream->id == *id)
805     return 0;
806
807   return -1;
808 }
809
810 static gint
811 find_stream_by_channel (GstRTSPStream * stream, gint * channel)
812 {
813   if (stream->channel[0] == *channel || stream->channel[1] == *channel)
814     return 0;
815
816   return -1;
817 }
818
819 static gint
820 find_stream_by_pt (GstRTSPStream * stream, gint * pt)
821 {
822   if (stream->pt == *pt)
823     return 0;
824
825   return -1;
826 }
827
828 static gint
829 find_stream_by_udpsrc (GstRTSPStream * stream, gconstpointer a)
830 {
831   GstElement *src = (GstElement *) a;
832
833   if (stream->udpsrc[0] == src)
834     return 0;
835   if (stream->udpsrc[1] == src)
836     return 0;
837
838   return -1;
839 }
840
841 static gint
842 find_stream_by_setup (GstRTSPStream * stream, gconstpointer a)
843 {
844   /* check qualified setup_url */
845   if (!strcmp (stream->conninfo.location, (gchar *) a))
846     return 0;
847   /* check original control_url */
848   if (!strcmp (stream->control_url, (gchar *) a))
849     return 0;
850
851   /* check if qualified setup_url ends with string */
852   if (g_str_has_suffix (stream->control_url, (gchar *) a))
853     return 0;
854
855   return -1;
856 }
857
858 static GstRTSPStream *
859 find_stream (GstRTSPSrc * src, gconstpointer data, gconstpointer func)
860 {
861   GList *lstream;
862
863   /* find and get stream */
864   if ((lstream = g_list_find_custom (src->streams, data, (GCompareFunc) func)))
865     return (GstRTSPStream *) lstream->data;
866
867   return NULL;
868 }
869
870 static const GstSDPBandwidth *
871 gst_rtspsrc_get_bandwidth (GstRTSPSrc * src, const GstSDPMessage * sdp,
872     const GstSDPMedia * media, const gchar * type)
873 {
874   guint i, len;
875
876   /* first look in the media specific section */
877   len = gst_sdp_media_bandwidths_len (media);
878   for (i = 0; i < len; i++) {
879     const GstSDPBandwidth *bw = gst_sdp_media_get_bandwidth (media, i);
880
881     if (strcmp (bw->bwtype, type) == 0)
882       return bw;
883   }
884   /* then look in the message specific section */
885   len = gst_sdp_message_bandwidths_len (sdp);
886   for (i = 0; i < len; i++) {
887     const GstSDPBandwidth *bw = gst_sdp_message_get_bandwidth (sdp, i);
888
889     if (strcmp (bw->bwtype, type) == 0)
890       return bw;
891   }
892   return NULL;
893 }
894
895 static void
896 gst_rtspsrc_collect_bandwidth (GstRTSPSrc * src, const GstSDPMessage * sdp,
897     const GstSDPMedia * media, GstRTSPStream * stream)
898 {
899   const GstSDPBandwidth *bw;
900
901   if ((bw = gst_rtspsrc_get_bandwidth (src, sdp, media, GST_SDP_BWTYPE_AS)))
902     stream->as_bandwidth = bw->bandwidth;
903   else
904     stream->as_bandwidth = -1;
905
906   if ((bw = gst_rtspsrc_get_bandwidth (src, sdp, media, GST_SDP_BWTYPE_RR)))
907     stream->rr_bandwidth = bw->bandwidth;
908   else
909     stream->rr_bandwidth = -1;
910
911   if ((bw = gst_rtspsrc_get_bandwidth (src, sdp, media, GST_SDP_BWTYPE_RS)))
912     stream->rs_bandwidth = bw->bandwidth;
913   else
914     stream->rs_bandwidth = -1;
915 }
916
917 static void
918 gst_rtspsrc_do_stream_connection (GstRTSPSrc * src, GstRTSPStream * stream,
919     const GstSDPConnection * conn)
920 {
921   if (conn->nettype == NULL || strcmp (conn->nettype, "IN") != 0)
922     return;
923
924   if (conn->addrtype == NULL)
925     return;
926
927   /* check for IPV6 */
928   if (strcmp (conn->addrtype, "IP4") == 0)
929     stream->is_ipv6 = FALSE;
930   else if (strcmp (conn->addrtype, "IP6") == 0)
931     stream->is_ipv6 = TRUE;
932   else
933     return;
934
935   /* save address */
936   g_free (stream->destination);
937   stream->destination = g_strdup (conn->address);
938
939   /* check for multicast */
940   stream->is_multicast =
941       gst_sdp_address_is_multicast (conn->nettype, conn->addrtype,
942       conn->address);
943   stream->ttl = conn->ttl;
944 }
945
946 /* Go over the connections for a stream.
947  * - If we are dealing with IPV6, we will setup IPV6 sockets for sending and
948  *   receiving.
949  * - If we are dealing with a localhost address, we disable multicast
950  */
951 static void
952 gst_rtspsrc_collect_connections (GstRTSPSrc * src, const GstSDPMessage * sdp,
953     const GstSDPMedia * media, GstRTSPStream * stream)
954 {
955   const GstSDPConnection *conn;
956   guint i, len;
957
958   /* first look in the media specific section */
959   len = gst_sdp_media_connections_len (media);
960   for (i = 0; i < len; i++) {
961     conn = gst_sdp_media_get_connection (media, i);
962
963     gst_rtspsrc_do_stream_connection (src, stream, conn);
964   }
965   /* then look in the message specific section */
966   if ((conn = gst_sdp_message_get_connection (sdp))) {
967     gst_rtspsrc_do_stream_connection (src, stream, conn);
968   }
969 }
970
971 static GstRTSPStream *
972 gst_rtspsrc_create_stream (GstRTSPSrc * src, GstSDPMessage * sdp, gint idx)
973 {
974   GstRTSPStream *stream;
975   const gchar *control_url;
976   const gchar *payload;
977   const GstSDPMedia *media;
978
979   /* get media, should not return NULL */
980   media = gst_sdp_message_get_media (sdp, idx);
981   if (media == NULL)
982     return NULL;
983
984   stream = g_new0 (GstRTSPStream, 1);
985   stream->parent = src;
986   /* we mark the pad as not linked, we will mark it as OK when we add the pad to
987    * the element. */
988   stream->last_ret = GST_FLOW_NOT_LINKED;
989   stream->added = FALSE;
990   stream->disabled = FALSE;
991   stream->id = src->numstreams++;
992   stream->eos = FALSE;
993   stream->discont = TRUE;
994   stream->seqbase = -1;
995   stream->timebase = -1;
996
997   /* collect bandwidth information for this steam. FIXME, configure in the RTP
998    * session manager to scale RTCP. */
999   gst_rtspsrc_collect_bandwidth (src, sdp, media, stream);
1000
1001   /* collect connection info */
1002   gst_rtspsrc_collect_connections (src, sdp, media, stream);
1003
1004   /* we must have a payload. No payload means we cannot create caps */
1005   /* FIXME, handle multiple formats. The problem here is that we just want to
1006    * take the first available format that we can handle but in order to do that
1007    * we need to scan for depayloader plugins. Scanning for payloader plugins is
1008    * also suboptimal because the user maybe just wants to save the raw stream
1009    * and then we don't care. */
1010   if ((payload = gst_sdp_media_get_format (media, 0))) {
1011     stream->pt = atoi (payload);
1012     /* convert caps */
1013     stream->caps = gst_rtspsrc_media_to_caps (stream->pt, media);
1014
1015     GST_DEBUG ("mapping sdp session level attributes to caps");
1016     gst_rtspsrc_sdp_attributes_to_caps (sdp->attributes, stream->caps);
1017     GST_DEBUG ("mapping sdp media level attributes to caps");
1018     gst_rtspsrc_sdp_attributes_to_caps (media->attributes, stream->caps);
1019
1020     if (stream->pt >= 96) {
1021       /* If we have a dynamic payload type, see if we have a stream with the
1022        * same payload number. If there is one, they are part of the same
1023        * container and we only need to add one pad. */
1024       if (find_stream (src, &stream->pt, (gpointer) find_stream_by_pt)) {
1025         stream->container = TRUE;
1026         GST_DEBUG ("found another stream with pt %d, marking as container",
1027             stream->pt);
1028       }
1029     }
1030   }
1031   /* collect port number */
1032   stream->port = gst_sdp_media_get_port (media);
1033
1034   /* get control url to construct the setup url. The setup url is used to
1035    * configure the transport of the stream and is used to identity the stream in
1036    * the RTP-Info header field returned from PLAY. */
1037   control_url = gst_sdp_media_get_attribute_val (media, "control");
1038   if (control_url == NULL)
1039     control_url = gst_sdp_message_get_attribute_val_n (sdp, "control", 0);
1040
1041   GST_DEBUG_OBJECT (src, "stream %d, (%p)", stream->id, stream);
1042   GST_DEBUG_OBJECT (src, " pt: %d", stream->pt);
1043   GST_DEBUG_OBJECT (src, " port: %d", stream->port);
1044   GST_DEBUG_OBJECT (src, " container: %d", stream->container);
1045   GST_DEBUG_OBJECT (src, " caps: %" GST_PTR_FORMAT, stream->caps);
1046   GST_DEBUG_OBJECT (src, " control: %s", GST_STR_NULL (control_url));
1047
1048   if (control_url != NULL) {
1049     stream->control_url = g_strdup (control_url);
1050     /* Build a fully qualified url using the content_base if any or by prefixing
1051      * the original request.
1052      * If the control_url starts with a '/' or a non rtsp: protocol we will most
1053      * likely build a URL that the server will fail to understand, this is ok,
1054      * we will fail then. */
1055     if (g_str_has_prefix (control_url, "rtsp://"))
1056       stream->conninfo.location = g_strdup (control_url);
1057     else {
1058       const gchar *base;
1059       gboolean has_slash;
1060
1061       if (g_strcmp0 (control_url, "*") == 0)
1062         control_url = "";
1063
1064       if (src->control)
1065         base = src->control;
1066       else if (src->content_base)
1067         base = src->content_base;
1068       else if (src->conninfo.url_str)
1069         base = src->conninfo.url_str;
1070       else
1071         base = "/";
1072
1073       /* check if the base ends or control starts with / */
1074       has_slash = g_str_has_prefix (control_url, "/");
1075       has_slash = has_slash || g_str_has_suffix (base, "/");
1076
1077       /* concatenate the two strings, insert / when not present */
1078       stream->conninfo.location =
1079           g_strdup_printf ("%s%s%s", base, has_slash ? "" : "/", control_url);
1080     }
1081   }
1082   GST_DEBUG_OBJECT (src, " setup: %s",
1083       GST_STR_NULL (stream->conninfo.location));
1084
1085   /* we keep track of all streams */
1086   src->streams = g_list_append (src->streams, stream);
1087
1088   return stream;
1089
1090   /* ERRORS */
1091 }
1092
1093 static void
1094 gst_rtspsrc_stream_free (GstRTSPSrc * src, GstRTSPStream * stream)
1095 {
1096   gint i;
1097
1098   GST_DEBUG_OBJECT (src, "free stream %p", stream);
1099
1100   if (stream->caps)
1101     gst_caps_unref (stream->caps);
1102
1103   g_free (stream->destination);
1104   g_free (stream->control_url);
1105   g_free (stream->conninfo.location);
1106
1107   for (i = 0; i < 2; i++) {
1108     if (stream->udpsrc[i]) {
1109       gst_element_set_state (stream->udpsrc[i], GST_STATE_NULL);
1110       gst_bin_remove (GST_BIN_CAST (src), stream->udpsrc[i]);
1111       gst_object_unref (stream->udpsrc[i]);
1112       stream->udpsrc[i] = NULL;
1113     }
1114     if (stream->channelpad[i]) {
1115       gst_object_unref (stream->channelpad[i]);
1116       stream->channelpad[i] = NULL;
1117     }
1118     if (stream->udpsink[i]) {
1119       gst_element_set_state (stream->udpsink[i], GST_STATE_NULL);
1120       gst_bin_remove (GST_BIN_CAST (src), stream->udpsink[i]);
1121       gst_object_unref (stream->udpsink[i]);
1122       stream->udpsink[i] = NULL;
1123     }
1124   }
1125   if (stream->fakesrc) {
1126     gst_element_set_state (stream->fakesrc, GST_STATE_NULL);
1127     gst_bin_remove (GST_BIN_CAST (src), stream->fakesrc);
1128     gst_object_unref (stream->fakesrc);
1129     stream->fakesrc = NULL;
1130   }
1131   if (stream->srcpad) {
1132     gst_pad_set_active (stream->srcpad, FALSE);
1133     if (stream->added) {
1134       gst_element_remove_pad (GST_ELEMENT_CAST (src), stream->srcpad);
1135       stream->added = FALSE;
1136     }
1137     stream->srcpad = NULL;
1138   }
1139   if (stream->rtcppad) {
1140     gst_object_unref (stream->rtcppad);
1141     stream->rtcppad = NULL;
1142   }
1143   if (stream->session) {
1144     g_object_unref (stream->session);
1145     stream->session = NULL;
1146   }
1147   g_free (stream);
1148 }
1149
1150 static void
1151 gst_rtspsrc_cleanup (GstRTSPSrc * src)
1152 {
1153   GList *walk;
1154
1155   GST_DEBUG_OBJECT (src, "cleanup");
1156
1157   for (walk = src->streams; walk; walk = g_list_next (walk)) {
1158     GstRTSPStream *stream = (GstRTSPStream *) walk->data;
1159
1160     gst_rtspsrc_stream_free (src, stream);
1161   }
1162   g_list_free (src->streams);
1163   src->streams = NULL;
1164   if (src->manager) {
1165     if (src->manager_sig_id) {
1166       g_signal_handler_disconnect (src->manager, src->manager_sig_id);
1167       src->manager_sig_id = 0;
1168     }
1169     gst_element_set_state (src->manager, GST_STATE_NULL);
1170     gst_bin_remove (GST_BIN_CAST (src), src->manager);
1171     src->manager = NULL;
1172   }
1173   src->numstreams = 0;
1174   if (src->props)
1175     gst_structure_free (src->props);
1176   src->props = NULL;
1177
1178   g_free (src->content_base);
1179   src->content_base = NULL;
1180
1181   g_free (src->control);
1182   src->control = NULL;
1183
1184   if (src->range)
1185     gst_rtsp_range_free (src->range);
1186   src->range = NULL;
1187
1188   /* don't clear the SDP when it was used in the url */
1189   if (src->sdp && !src->from_sdp) {
1190     gst_sdp_message_free (src->sdp);
1191     src->sdp = NULL;
1192   }
1193 }
1194
1195 #define PARSE_INT(p, del, res)          \
1196 G_STMT_START {                          \
1197   gchar *t = p;                         \
1198   p = strstr (p, del);                  \
1199   if (p == NULL)                        \
1200     res = -1;                           \
1201   else {                                \
1202     *p = '\0';                          \
1203     p++;                                \
1204     res = atoi (t);                     \
1205   }                                     \
1206 } G_STMT_END
1207
1208 #define PARSE_STRING(p, del, res)       \
1209 G_STMT_START {                          \
1210   gchar *t = p;                         \
1211   p = strstr (p, del);                  \
1212   if (p == NULL) {                      \
1213     res = NULL;                         \
1214     p = t;                              \
1215   }                                     \
1216   else {                                \
1217     *p = '\0';                          \
1218     p++;                                \
1219     res = t;                            \
1220   }                                     \
1221 } G_STMT_END
1222
1223 #define SKIP_SPACES(p)                  \
1224   while (*p && g_ascii_isspace (*p))    \
1225     p++;
1226
1227 /* rtpmap contains:
1228  *
1229  *  <payload> <encoding_name>/<clock_rate>[/<encoding_params>]
1230  */
1231 static gboolean
1232 gst_rtspsrc_parse_rtpmap (const gchar * rtpmap, gint * payload, gchar ** name,
1233     gint * rate, gchar ** params)
1234 {
1235   gchar *p, *t;
1236
1237   p = (gchar *) rtpmap;
1238
1239   PARSE_INT (p, " ", *payload);
1240   if (*payload == -1)
1241     return FALSE;
1242
1243   SKIP_SPACES (p);
1244   if (*p == '\0')
1245     return FALSE;
1246
1247   PARSE_STRING (p, "/", *name);
1248   if (*name == NULL) {
1249     GST_DEBUG ("no rate, name %s", p);
1250     /* no rate, assume -1 then, this is not supposed to happen but RealMedia
1251      * streams seem to omit the rate. */
1252     *name = p;
1253     *rate = -1;
1254     return TRUE;
1255   }
1256
1257   t = p;
1258   p = strstr (p, "/");
1259   if (p == NULL) {
1260     *rate = atoi (t);
1261     return TRUE;
1262   }
1263   *p = '\0';
1264   p++;
1265   *rate = atoi (t);
1266
1267   t = p;
1268   if (*p == '\0')
1269     return TRUE;
1270   *params = t;
1271
1272   return TRUE;
1273 }
1274
1275 /*
1276  * Mapping SDP attributes to caps
1277  *
1278  * prepend 'a-' to IANA registered sdp attributes names
1279  * (ie: not prefixed with 'x-') in order to avoid
1280  * collision with gstreamer standard caps properties names
1281  */
1282 static void
1283 gst_rtspsrc_sdp_attributes_to_caps (GArray * attributes, GstCaps * caps)
1284 {
1285   if (attributes->len > 0) {
1286     GstStructure *s;
1287     guint i;
1288
1289     s = gst_caps_get_structure (caps, 0);
1290
1291     for (i = 0; i < attributes->len; i++) {
1292       GstSDPAttribute *attr = &g_array_index (attributes, GstSDPAttribute, i);
1293       gchar *tofree, *key;
1294
1295       key = attr->key;
1296
1297       /* skip some of the attribute we already handle */
1298       if (!strcmp (key, "fmtp"))
1299         continue;
1300       if (!strcmp (key, "rtpmap"))
1301         continue;
1302       if (!strcmp (key, "control"))
1303         continue;
1304       if (!strcmp (key, "range"))
1305         continue;
1306
1307       /* string must be valid UTF8 */
1308       if (!g_utf8_validate (attr->value, -1, NULL))
1309         continue;
1310
1311       if (!g_str_has_prefix (key, "x-"))
1312         tofree = key = g_strdup_printf ("a-%s", key);
1313       else
1314         tofree = NULL;
1315
1316       GST_DEBUG ("adding caps: %s=%s", key, attr->value);
1317       gst_structure_set (s, key, G_TYPE_STRING, attr->value, NULL);
1318       g_free (tofree);
1319     }
1320   }
1321 }
1322
1323 /*
1324  *  Mapping of caps to and from SDP fields:
1325  *
1326  *   m=<media> <UDP port> RTP/AVP <payload>
1327  *   a=rtpmap:<payload> <encoding_name>/<clock_rate>[/<encoding_params>]
1328  *   a=fmtp:<payload> <param>[=<value>];...
1329  */
1330 static GstCaps *
1331 gst_rtspsrc_media_to_caps (gint pt, const GstSDPMedia * media)
1332 {
1333   GstCaps *caps;
1334   const gchar *rtpmap;
1335   const gchar *fmtp;
1336   gchar *name = NULL;
1337   gint rate = -1;
1338   gchar *params = NULL;
1339   gchar *tmp;
1340   GstStructure *s;
1341   gint payload = 0;
1342   gboolean ret;
1343
1344   /* get and parse rtpmap */
1345   if ((rtpmap = gst_sdp_media_get_attribute_val (media, "rtpmap"))) {
1346     ret = gst_rtspsrc_parse_rtpmap (rtpmap, &payload, &name, &rate, &params);
1347     if (ret) {
1348       if (payload != pt) {
1349         /* we ignore the rtpmap if the payload type is different. */
1350         g_warning ("rtpmap of wrong payload type, ignoring");
1351         name = NULL;
1352         rate = -1;
1353         params = NULL;
1354       }
1355     } else {
1356       /* if we failed to parse the rtpmap for a dynamic payload type, we have an
1357        * error */
1358       if (pt >= 96)
1359         goto no_rtpmap;
1360       /* else we can ignore */
1361       g_warning ("error parsing rtpmap, ignoring");
1362     }
1363   } else {
1364     /* dynamic payloads need rtpmap or we fail */
1365     if (pt >= 96)
1366       goto no_rtpmap;
1367   }
1368   /* check if we have a rate, if not, we need to look up the rate from the
1369    * default rates based on the payload types. */
1370   if (rate == -1) {
1371     const GstRTPPayloadInfo *info;
1372
1373     if (GST_RTP_PAYLOAD_IS_DYNAMIC (pt)) {
1374       /* dynamic types, use media and encoding_name */
1375       tmp = g_ascii_strdown (media->media, -1);
1376       info = gst_rtp_payload_info_for_name (tmp, name);
1377       g_free (tmp);
1378     } else {
1379       /* static types, use payload type */
1380       info = gst_rtp_payload_info_for_pt (pt);
1381     }
1382
1383     if (info) {
1384       if ((rate = info->clock_rate) == 0)
1385         rate = -1;
1386     }
1387     /* we fail if we cannot find one */
1388     if (rate == -1)
1389       goto no_rate;
1390   }
1391
1392   tmp = g_ascii_strdown (media->media, -1);
1393   caps = gst_caps_new_simple ("application/x-unknown",
1394       "media", G_TYPE_STRING, tmp, "payload", G_TYPE_INT, pt, NULL);
1395   g_free (tmp);
1396   s = gst_caps_get_structure (caps, 0);
1397
1398   gst_structure_set (s, "clock-rate", G_TYPE_INT, rate, NULL);
1399
1400   /* encoding name must be upper case */
1401   if (name != NULL) {
1402     tmp = g_ascii_strup (name, -1);
1403     gst_structure_set (s, "encoding-name", G_TYPE_STRING, tmp, NULL);
1404     g_free (tmp);
1405   }
1406
1407   /* params must be lower case */
1408   if (params != NULL) {
1409     tmp = g_ascii_strdown (params, -1);
1410     gst_structure_set (s, "encoding-params", G_TYPE_STRING, tmp, NULL);
1411     g_free (tmp);
1412   }
1413
1414   /* parse optional fmtp: field */
1415   if ((fmtp = gst_sdp_media_get_attribute_val (media, "fmtp"))) {
1416     gchar *p;
1417     gint payload = 0;
1418
1419     p = (gchar *) fmtp;
1420
1421     /* p is now of the format <payload> <param>[=<value>];... */
1422     PARSE_INT (p, " ", payload);
1423     if (payload != -1 && payload == pt) {
1424       gchar **pairs;
1425       gint i;
1426
1427       /* <param>[=<value>] are separated with ';' */
1428       pairs = g_strsplit (p, ";", 0);
1429       for (i = 0; pairs[i]; i++) {
1430         gchar *valpos;
1431         const gchar *val, *key;
1432
1433         /* the key may not have a '=', the value can have other '='s */
1434         valpos = strstr (pairs[i], "=");
1435         if (valpos) {
1436           /* we have a '=' and thus a value, remove the '=' with \0 */
1437           *valpos = '\0';
1438           /* value is everything between '=' and ';'. We split the pairs at ;
1439            * boundaries so we can take the remainder of the value. Some servers
1440            * put spaces around the value which we strip off here. Alternatively
1441            * we could strip those spaces in the depayloaders should these spaces
1442            * actually carry any meaning in the future. */
1443           val = g_strstrip (valpos + 1);
1444         } else {
1445           /* simple <param>;.. is translated into <param>=1;... */
1446           val = "1";
1447         }
1448         /* strip the key of spaces, convert key to lowercase but not the value. */
1449         key = g_strstrip (pairs[i]);
1450         if (strlen (key) > 1) {
1451           tmp = g_ascii_strdown (key, -1);
1452           gst_structure_set (s, tmp, G_TYPE_STRING, val, NULL);
1453           g_free (tmp);
1454         }
1455       }
1456       g_strfreev (pairs);
1457     }
1458   }
1459   return caps;
1460
1461   /* ERRORS */
1462 no_rtpmap:
1463   {
1464     g_warning ("rtpmap type not given for dynamic payload %d", pt);
1465     return NULL;
1466   }
1467 no_rate:
1468   {
1469     g_warning ("rate unknown for payload type %d", pt);
1470     return NULL;
1471   }
1472 }
1473
1474 static gboolean
1475 gst_rtspsrc_alloc_udp_ports (GstRTSPStream * stream,
1476     gint * rtpport, gint * rtcpport)
1477 {
1478   GstRTSPSrc *src;
1479   GstStateChangeReturn ret;
1480   GstElement *udpsrc0, *udpsrc1;
1481   gint tmp_rtp, tmp_rtcp;
1482   guint count;
1483   const gchar *host;
1484
1485   src = stream->parent;
1486
1487   udpsrc0 = NULL;
1488   udpsrc1 = NULL;
1489   count = 0;
1490
1491   /* Start at next port */
1492   tmp_rtp = src->next_port_num;
1493
1494   if (stream->is_ipv6)
1495     host = "udp://[::0]";
1496   else
1497     host = "udp://0.0.0.0";
1498
1499   /* try to allocate 2 UDP ports, the RTP port should be an even
1500    * number and the RTCP port should be the next (uneven) port */
1501 again:
1502
1503   if (tmp_rtp != 0 && src->client_port_range.max > 0 &&
1504       tmp_rtp >= src->client_port_range.max)
1505     goto no_ports;
1506
1507   udpsrc0 = gst_element_make_from_uri (GST_URI_SRC, host, NULL);
1508   if (udpsrc0 == NULL)
1509     goto no_udp_protocol;
1510   g_object_set (G_OBJECT (udpsrc0), "port", tmp_rtp, "reuse", FALSE, NULL);
1511
1512   if (src->udp_buffer_size != 0)
1513     g_object_set (G_OBJECT (udpsrc0), "buffer-size", src->udp_buffer_size,
1514         NULL);
1515
1516   ret = gst_element_set_state (udpsrc0, GST_STATE_PAUSED);
1517   if (ret == GST_STATE_CHANGE_FAILURE) {
1518     if (tmp_rtp != 0) {
1519       GST_DEBUG_OBJECT (src, "Unable to make udpsrc from RTP port %d", tmp_rtp);
1520
1521       tmp_rtp += 2;
1522       if (++count > src->retry)
1523         goto no_ports;
1524
1525       GST_DEBUG_OBJECT (src, "free RTP udpsrc");
1526       gst_element_set_state (udpsrc0, GST_STATE_NULL);
1527       gst_object_unref (udpsrc0);
1528
1529       GST_DEBUG_OBJECT (src, "retry %d", count);
1530       goto again;
1531     }
1532     goto no_udp_protocol;
1533   }
1534
1535   g_object_get (G_OBJECT (udpsrc0), "port", &tmp_rtp, NULL);
1536   GST_DEBUG_OBJECT (src, "got RTP port %d", tmp_rtp);
1537
1538   /* check if port is even */
1539   if ((tmp_rtp & 0x01) != 0) {
1540     /* port not even, close and allocate another */
1541     if (++count > src->retry)
1542       goto no_ports;
1543
1544     GST_DEBUG_OBJECT (src, "RTP port not even");
1545
1546     GST_DEBUG_OBJECT (src, "free RTP udpsrc");
1547     gst_element_set_state (udpsrc0, GST_STATE_NULL);
1548     gst_object_unref (udpsrc0);
1549
1550     GST_DEBUG_OBJECT (src, "retry %d", count);
1551     tmp_rtp++;
1552     goto again;
1553   }
1554
1555   /* allocate port+1 for RTCP now */
1556   udpsrc1 = gst_element_make_from_uri (GST_URI_SRC, host, NULL);
1557   if (udpsrc1 == NULL)
1558     goto no_udp_rtcp_protocol;
1559
1560   /* set port */
1561   tmp_rtcp = tmp_rtp + 1;
1562   if (src->client_port_range.max > 0 && tmp_rtcp >= src->client_port_range.max)
1563     goto no_ports;
1564
1565   g_object_set (G_OBJECT (udpsrc1), "port", tmp_rtcp, "reuse", FALSE, NULL);
1566
1567   GST_DEBUG_OBJECT (src, "starting RTCP on port %d", tmp_rtcp);
1568   ret = gst_element_set_state (udpsrc1, GST_STATE_PAUSED);
1569   /* tmp_rtcp port is busy already : retry to make rtp/rtcp pair */
1570   if (ret == GST_STATE_CHANGE_FAILURE) {
1571     GST_DEBUG_OBJECT (src, "Unable to make udpsrc from RTCP port %d", tmp_rtcp);
1572
1573     if (++count > src->retry)
1574       goto no_ports;
1575
1576     GST_DEBUG_OBJECT (src, "free RTP udpsrc");
1577     gst_element_set_state (udpsrc0, GST_STATE_NULL);
1578     gst_object_unref (udpsrc0);
1579
1580     GST_DEBUG_OBJECT (src, "free RTCP udpsrc");
1581     gst_element_set_state (udpsrc1, GST_STATE_NULL);
1582     gst_object_unref (udpsrc1);
1583     udpsrc1 = NULL;
1584
1585     tmp_rtp += 2;
1586     GST_DEBUG_OBJECT (src, "retry %d", count);
1587     goto again;
1588   }
1589
1590   /* all fine, do port check */
1591   g_object_get (G_OBJECT (udpsrc0), "port", rtpport, NULL);
1592   g_object_get (G_OBJECT (udpsrc1), "port", rtcpport, NULL);
1593
1594   /* this should not happen... */
1595   if (*rtpport != tmp_rtp || *rtcpport != tmp_rtcp)
1596     goto port_error;
1597
1598   /* we keep these elements, we configure all in configure_transport when the
1599    * server told us to really use the UDP ports. */
1600   stream->udpsrc[0] = gst_object_ref (udpsrc0);
1601   stream->udpsrc[1] = gst_object_ref (udpsrc1);
1602
1603   /* keep track of next available port number when we have a range
1604    * configured */
1605   if (src->next_port_num != 0)
1606     src->next_port_num = tmp_rtcp + 1;
1607
1608   /* they are ours now */
1609   gst_object_sink (udpsrc0);
1610   gst_object_sink (udpsrc1);
1611
1612   return TRUE;
1613
1614   /* ERRORS */
1615 no_udp_protocol:
1616   {
1617     GST_DEBUG_OBJECT (src, "could not get UDP source");
1618     goto cleanup;
1619   }
1620 no_ports:
1621   {
1622     GST_DEBUG_OBJECT (src, "could not allocate UDP port pair after %d retries",
1623         count);
1624     goto cleanup;
1625   }
1626 no_udp_rtcp_protocol:
1627   {
1628     GST_DEBUG_OBJECT (src, "could not get UDP source for RTCP");
1629     goto cleanup;
1630   }
1631 port_error:
1632   {
1633     GST_DEBUG_OBJECT (src, "ports don't match rtp: %d<->%d, rtcp: %d<->%d",
1634         tmp_rtp, *rtpport, tmp_rtcp, *rtcpport);
1635     goto cleanup;
1636   }
1637 cleanup:
1638   {
1639     if (udpsrc0) {
1640       gst_element_set_state (udpsrc0, GST_STATE_NULL);
1641       gst_object_unref (udpsrc0);
1642     }
1643     if (udpsrc1) {
1644       gst_element_set_state (udpsrc1, GST_STATE_NULL);
1645       gst_object_unref (udpsrc1);
1646     }
1647     return FALSE;
1648   }
1649 }
1650
1651 static void
1652 gst_rtspsrc_flush (GstRTSPSrc * src, gboolean flush)
1653 {
1654   GstEvent *event;
1655   gint cmd, i;
1656   GstState state;
1657   GList *walk;
1658   GstClock *clock;
1659   GstClockTime base_time = GST_CLOCK_TIME_NONE;
1660
1661   if (flush) {
1662     event = gst_event_new_flush_start ();
1663     GST_DEBUG_OBJECT (src, "start flush");
1664     cmd = CMD_WAIT;
1665     state = GST_STATE_PAUSED;
1666   } else {
1667     event = gst_event_new_flush_stop ();
1668     GST_DEBUG_OBJECT (src, "stop flush");
1669     cmd = CMD_LOOP;
1670     state = GST_STATE_PLAYING;
1671     clock = gst_element_get_clock (GST_ELEMENT_CAST (src));
1672     if (clock) {
1673       base_time = gst_clock_get_time (clock);
1674       gst_object_unref (clock);
1675     }
1676   }
1677   gst_rtspsrc_push_event (src, event, FALSE);
1678   gst_rtspsrc_loop_send_cmd (src, cmd, flush);
1679
1680   /* set up manager before data-flow resumes */
1681   /* to manage jitterbuffer buffer mode */
1682   if (src->manager) {
1683     gst_element_set_base_time (GST_ELEMENT_CAST (src->manager), base_time);
1684     /* and to have base_time trickle further down,
1685      * e.g. to jitterbuffer for its timeout handling */
1686     if (base_time != -1)
1687       gst_element_set_state (GST_ELEMENT_CAST (src->manager), state);
1688   }
1689
1690   /* make running time start start at 0 again */
1691   for (walk = src->streams; walk; walk = g_list_next (walk)) {
1692     GstRTSPStream *stream = (GstRTSPStream *) walk->data;
1693
1694     for (i = 0; i < 2; i++) {
1695       /* for udp case */
1696       if (stream->udpsrc[i]) {
1697         if (base_time != -1)
1698           gst_element_set_base_time (stream->udpsrc[i], base_time);
1699         gst_element_set_state (stream->udpsrc[i], state);
1700       }
1701     }
1702   }
1703   /* for tcp interleaved case */
1704   if (base_time != -1)
1705     gst_element_set_base_time (GST_ELEMENT_CAST (src), base_time);
1706 }
1707
1708 static GstRTSPResult
1709 gst_rtspsrc_connection_send (GstRTSPSrc * src, GstRTSPConnection * conn,
1710     GstRTSPMessage * message, GTimeVal * timeout)
1711 {
1712   GstRTSPResult ret;
1713
1714   if (conn)
1715     ret = gst_rtsp_connection_send (conn, message, timeout);
1716   else
1717     ret = GST_RTSP_ERROR;
1718
1719   return ret;
1720 }
1721
1722 static GstRTSPResult
1723 gst_rtspsrc_connection_receive (GstRTSPSrc * src, GstRTSPConnection * conn,
1724     GstRTSPMessage * message, GTimeVal * timeout)
1725 {
1726   GstRTSPResult ret;
1727
1728   if (conn)
1729     ret = gst_rtsp_connection_receive (conn, message, timeout);
1730   else
1731     ret = GST_RTSP_ERROR;
1732
1733   return ret;
1734 }
1735
1736 static void
1737 gst_rtspsrc_get_position (GstRTSPSrc * src)
1738 {
1739   GstQuery *query;
1740   GList *walk;
1741
1742   query = gst_query_new_position (GST_FORMAT_TIME);
1743   /*  should be known somewhere down the stream (e.g. jitterbuffer) */
1744   for (walk = src->streams; walk; walk = g_list_next (walk)) {
1745     GstRTSPStream *stream = (GstRTSPStream *) walk->data;
1746     GstFormat fmt;
1747     gint64 pos;
1748
1749     if (stream->srcpad) {
1750       if (gst_pad_query (stream->srcpad, query)) {
1751         gst_query_parse_position (query, &fmt, &pos);
1752         GST_DEBUG_OBJECT (src, "retaining position %" GST_TIME_FORMAT,
1753             GST_TIME_ARGS (pos));
1754         src->last_pos = pos;
1755         return;
1756       }
1757     }
1758   }
1759
1760   src->last_pos = 0;
1761 }
1762
1763 static gboolean
1764 gst_rtspsrc_do_seek (GstRTSPSrc * src, GstSegment * segment)
1765 {
1766   src->state = GST_RTSP_STATE_SEEKING;
1767   /* PLAY will add the range header now. */
1768   src->need_range = TRUE;
1769
1770   return TRUE;
1771 }
1772
1773 static gboolean
1774 gst_rtspsrc_perform_seek (GstRTSPSrc * src, GstEvent * event)
1775 {
1776   gdouble rate;
1777   GstFormat format;
1778   GstSeekFlags flags;
1779   GstSeekType cur_type = GST_SEEK_TYPE_NONE, stop_type;
1780   gint64 cur, stop;
1781   gboolean flush, skip;
1782   gboolean update;
1783   gboolean playing;
1784   GstSegment seeksegment = { 0, };
1785   GList *walk;
1786
1787   if (event) {
1788     GST_DEBUG_OBJECT (src, "doing seek with event");
1789
1790     gst_event_parse_seek (event, &rate, &format, &flags,
1791         &cur_type, &cur, &stop_type, &stop);
1792
1793     /* no negative rates yet */
1794     if (rate < 0.0)
1795       goto negative_rate;
1796
1797     /* we need TIME format */
1798     if (format != src->segment.format)
1799       goto no_format;
1800   } else {
1801     GST_DEBUG_OBJECT (src, "doing seek without event");
1802     flags = 0;
1803     cur_type = GST_SEEK_TYPE_SET;
1804     stop_type = GST_SEEK_TYPE_SET;
1805   }
1806
1807   /* get flush flag */
1808   flush = flags & GST_SEEK_FLAG_FLUSH;
1809   skip = flags & GST_SEEK_FLAG_SKIP;
1810
1811   /* now we need to make sure the streaming thread is stopped. We do this by
1812    * either sending a FLUSH_START event downstream which will cause the
1813    * streaming thread to stop with a WRONG_STATE.
1814    * For a non-flushing seek we simply pause the task, which will happen as soon
1815    * as it completes one iteration (and thus might block when the sink is
1816    * blocking in preroll). */
1817   if (flush) {
1818     GST_DEBUG_OBJECT (src, "starting flush");
1819     gst_rtspsrc_flush (src, TRUE);
1820   } else {
1821     if (src->task) {
1822       gst_task_pause (src->task);
1823     }
1824   }
1825
1826   /* we should now be able to grab the streaming thread because we stopped it
1827    * with the above flush/pause code */
1828   GST_RTSP_STREAM_LOCK (src);
1829
1830   /* stop flushing state */
1831   gst_rtspsrc_loop_send_cmd (src, CMD_WAIT, FALSE);
1832
1833   GST_DEBUG_OBJECT (src, "stopped streaming");
1834
1835   /* copy segment, we need this because we still need the old
1836    * segment when we close the current segment. */
1837   memcpy (&seeksegment, &src->segment, sizeof (GstSegment));
1838
1839   /* configure the seek parameters in the seeksegment. We will then have the
1840    * right values in the segment to perform the seek */
1841   if (event) {
1842     GST_DEBUG_OBJECT (src, "configuring seek");
1843     gst_segment_set_seek (&seeksegment, rate, format, flags,
1844         cur_type, cur, stop_type, stop, &update);
1845   }
1846
1847   /* figure out the last position we need to play. If it's configured (stop !=
1848    * -1), use that, else we play until the total duration of the file */
1849   if ((stop = seeksegment.stop) == -1)
1850     stop = seeksegment.duration;
1851
1852   playing = (src->state == GST_RTSP_STATE_PLAYING);
1853
1854   /* if we were playing, pause first */
1855   if (playing) {
1856     /* obtain current position in case seek fails */
1857     gst_rtspsrc_get_position (src);
1858     gst_rtspsrc_pause (src, FALSE, FALSE);
1859   }
1860
1861   gst_rtspsrc_do_seek (src, &seeksegment);
1862
1863   /* and continue playing */
1864   if (playing)
1865     gst_rtspsrc_play (src, &seeksegment, FALSE);
1866
1867   /* prepare for streaming again */
1868   if (flush) {
1869     /* if we started flush, we stop now */
1870     GST_DEBUG_OBJECT (src, "stopping flush");
1871     gst_rtspsrc_flush (src, FALSE);
1872   } else if (src->running) {
1873     /* we are running the current segment and doing a non-flushing seek,
1874      * close the segment first based on the previous last_stop. */
1875     GST_DEBUG_OBJECT (src, "closing running segment %" G_GINT64_FORMAT
1876         " to %" G_GINT64_FORMAT, src->segment.accum, src->segment.last_stop);
1877
1878     /* queue the segment for sending in the stream thread */
1879     if (src->close_segment)
1880       gst_event_unref (src->close_segment);
1881     src->close_segment = gst_event_new_new_segment (TRUE,
1882         src->segment.rate, src->segment.format,
1883         src->segment.accum, src->segment.last_stop, src->segment.accum);
1884
1885     /* keep track of our last_stop */
1886     seeksegment.accum = src->segment.last_stop;
1887   }
1888
1889   /* now we did the seek and can activate the new segment values */
1890   memcpy (&src->segment, &seeksegment, sizeof (GstSegment));
1891
1892   /* if we're doing a segment seek, post a SEGMENT_START message */
1893   if (src->segment.flags & GST_SEEK_FLAG_SEGMENT) {
1894     gst_element_post_message (GST_ELEMENT_CAST (src),
1895         gst_message_new_segment_start (GST_OBJECT_CAST (src),
1896             src->segment.format, src->segment.last_stop));
1897   }
1898
1899   /* now create the newsegment */
1900   GST_DEBUG_OBJECT (src, "Creating newsegment from %" G_GINT64_FORMAT
1901       " to %" G_GINT64_FORMAT, src->segment.last_stop, stop);
1902
1903   /* store the newsegment event so it can be sent from the streaming thread. */
1904   if (src->start_segment)
1905     gst_event_unref (src->start_segment);
1906   src->start_segment =
1907       gst_event_new_new_segment (FALSE, src->segment.rate,
1908       src->segment.format, src->segment.last_stop, stop,
1909       src->segment.last_stop);
1910
1911   /* mark discont */
1912   GST_DEBUG_OBJECT (src, "mark DISCONT, we did a seek to another position");
1913   for (walk = src->streams; walk; walk = g_list_next (walk)) {
1914     GstRTSPStream *stream = (GstRTSPStream *) walk->data;
1915     stream->discont = TRUE;
1916   }
1917   src->skip = skip;
1918
1919   GST_RTSP_STREAM_UNLOCK (src);
1920
1921   return TRUE;
1922
1923   /* ERRORS */
1924 negative_rate:
1925   {
1926     GST_DEBUG_OBJECT (src, "negative playback rates are not supported yet.");
1927     return FALSE;
1928   }
1929 no_format:
1930   {
1931     GST_DEBUG_OBJECT (src, "unsupported format given, seek aborted.");
1932     return FALSE;
1933   }
1934 }
1935
1936 static gboolean
1937 gst_rtspsrc_handle_src_event (GstPad * pad, GstEvent * event)
1938 {
1939   GstRTSPSrc *src;
1940   gboolean res = TRUE;
1941   gboolean forward;
1942
1943   src = GST_RTSPSRC_CAST (gst_pad_get_parent (pad));
1944
1945   GST_DEBUG_OBJECT (src, "pad %s:%s received event %s",
1946       GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE_NAME (event));
1947
1948   switch (GST_EVENT_TYPE (event)) {
1949     case GST_EVENT_SEEK:
1950       res = gst_rtspsrc_perform_seek (src, event);
1951       forward = FALSE;
1952       break;
1953     case GST_EVENT_QOS:
1954     case GST_EVENT_NAVIGATION:
1955     case GST_EVENT_LATENCY:
1956     default:
1957       forward = TRUE;
1958       break;
1959   }
1960   if (forward) {
1961     GstPad *target;
1962
1963     if ((target = gst_ghost_pad_get_target (GST_GHOST_PAD_CAST (pad)))) {
1964       res = gst_pad_send_event (target, event);
1965       gst_object_unref (target);
1966     } else {
1967       gst_event_unref (event);
1968     }
1969   } else {
1970     gst_event_unref (event);
1971   }
1972   gst_object_unref (src);
1973
1974   return res;
1975 }
1976
1977 /* this is the final event function we receive on the internal source pad when
1978  * we deal with TCP connections */
1979 static gboolean
1980 gst_rtspsrc_handle_internal_src_event (GstPad * pad, GstEvent * event)
1981 {
1982   GstRTSPSrc *src;
1983   gboolean res;
1984
1985   src = GST_RTSPSRC_CAST (gst_pad_get_element_private (pad));
1986
1987   GST_DEBUG_OBJECT (src, "pad %s:%s received event %s",
1988       GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE_NAME (event));
1989
1990   switch (GST_EVENT_TYPE (event)) {
1991     case GST_EVENT_SEEK:
1992     case GST_EVENT_QOS:
1993     case GST_EVENT_NAVIGATION:
1994     case GST_EVENT_LATENCY:
1995     default:
1996       gst_event_unref (event);
1997       res = TRUE;
1998       break;
1999   }
2000   return res;
2001 }
2002
2003 /* this is the final query function we receive on the internal source pad when
2004  * we deal with TCP connections */
2005 static gboolean
2006 gst_rtspsrc_handle_internal_src_query (GstPad * pad, GstQuery * query)
2007 {
2008   GstRTSPSrc *src;
2009   gboolean res = TRUE;
2010
2011   src = GST_RTSPSRC_CAST (gst_pad_get_element_private (pad));
2012
2013   GST_DEBUG_OBJECT (src, "pad %s:%s received query %s",
2014       GST_DEBUG_PAD_NAME (pad), GST_QUERY_TYPE_NAME (query));
2015
2016   switch (GST_QUERY_TYPE (query)) {
2017     case GST_QUERY_POSITION:
2018     {
2019       /* no idea */
2020       break;
2021     }
2022     case GST_QUERY_DURATION:
2023     {
2024       GstFormat format;
2025
2026       gst_query_parse_duration (query, &format, NULL);
2027
2028       switch (format) {
2029         case GST_FORMAT_TIME:
2030           gst_query_set_duration (query, format, src->segment.duration);
2031           break;
2032         default:
2033           res = FALSE;
2034           break;
2035       }
2036       break;
2037     }
2038     case GST_QUERY_LATENCY:
2039     {
2040       /* we are live with a min latency of 0 and unlimited max latency, this
2041        * result will be updated by the session manager if there is any. */
2042       gst_query_set_latency (query, TRUE, 0, -1);
2043       break;
2044     }
2045     default:
2046       break;
2047   }
2048
2049   return res;
2050 }
2051
2052 /* this query is executed on the ghost source pad exposed on rtspsrc. */
2053 static gboolean
2054 gst_rtspsrc_handle_src_query (GstPad * pad, GstQuery * query)
2055 {
2056   GstRTSPSrc *src;
2057   gboolean res = FALSE;
2058
2059   src = GST_RTSPSRC_CAST (gst_pad_get_parent (pad));
2060
2061   GST_DEBUG_OBJECT (src, "pad %s:%s received query %s",
2062       GST_DEBUG_PAD_NAME (pad), GST_QUERY_TYPE_NAME (query));
2063
2064   switch (GST_QUERY_TYPE (query)) {
2065     case GST_QUERY_DURATION:
2066     {
2067       GstFormat format;
2068
2069       gst_query_parse_duration (query, &format, NULL);
2070
2071       switch (format) {
2072         case GST_FORMAT_TIME:
2073           gst_query_set_duration (query, format, src->segment.duration);
2074           res = TRUE;
2075           break;
2076         default:
2077           break;
2078       }
2079       break;
2080     }
2081     case GST_QUERY_SEEKING:
2082     {
2083       GstFormat format;
2084
2085       gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
2086       if (format == GST_FORMAT_TIME) {
2087         gboolean seekable =
2088             src->cur_protocols != GST_RTSP_LOWER_TRANS_UDP_MCAST;
2089
2090         /* seeking without duration is unlikely */
2091         seekable = seekable && src->seekable && src->segment.duration &&
2092             GST_CLOCK_TIME_IS_VALID (src->segment.duration);
2093
2094         /* FIXME ?? should we have 0 and segment.duration here; see demuxers */
2095         gst_query_set_seeking (query, GST_FORMAT_TIME, seekable,
2096             src->segment.start, src->segment.stop);
2097         res = TRUE;
2098       }
2099       break;
2100     }
2101     default:
2102     {
2103       GstPad *target = gst_ghost_pad_get_target (GST_GHOST_PAD_CAST (pad));
2104
2105       /* forward the query to the proxy target pad */
2106       if (target) {
2107         res = gst_pad_query (target, query);
2108         gst_object_unref (target);
2109       }
2110       break;
2111     }
2112   }
2113   gst_object_unref (src);
2114
2115   return res;
2116 }
2117
2118 /* callback for RTCP messages to be sent to the server when operating in TCP
2119  * mode. */
2120 static GstFlowReturn
2121 gst_rtspsrc_sink_chain (GstPad * pad, GstBuffer * buffer)
2122 {
2123   GstRTSPSrc *src;
2124   GstRTSPStream *stream;
2125   GstFlowReturn res = GST_FLOW_OK;
2126   guint8 *data;
2127   guint size;
2128   GstRTSPResult ret;
2129   GstRTSPMessage message = { 0 };
2130   GstRTSPConnection *conn;
2131
2132   stream = (GstRTSPStream *) gst_pad_get_element_private (pad);
2133   src = stream->parent;
2134
2135   data = GST_BUFFER_DATA (buffer);
2136   size = GST_BUFFER_SIZE (buffer);
2137
2138   gst_rtsp_message_init_data (&message, stream->channel[1]);
2139
2140   /* lend the body data to the message */
2141   gst_rtsp_message_take_body (&message, data, size);
2142
2143   if (stream->conninfo.connection)
2144     conn = stream->conninfo.connection;
2145   else
2146     conn = src->conninfo.connection;
2147
2148   GST_DEBUG_OBJECT (src, "sending %u bytes RTCP", size);
2149   ret = gst_rtspsrc_connection_send (src, conn, &message, NULL);
2150   GST_DEBUG_OBJECT (src, "sent RTCP, %d", ret);
2151
2152   /* and steal it away again because we will free it when unreffing the
2153    * buffer */
2154   gst_rtsp_message_steal_body (&message, &data, &size);
2155   gst_rtsp_message_unset (&message);
2156
2157   gst_buffer_unref (buffer);
2158
2159   return res;
2160 }
2161
2162 static void
2163 pad_unblocked (GstPad * pad, gboolean blocked, GstRTSPSrc * src)
2164 {
2165   GST_DEBUG_OBJECT (src, "pad %s:%s unblocked", GST_DEBUG_PAD_NAME (pad));
2166 }
2167
2168 static void
2169 pad_blocked (GstPad * pad, gboolean blocked, GstRTSPSrc * src)
2170 {
2171   GST_DEBUG_OBJECT (src, "pad %s:%s blocked, activating streams",
2172       GST_DEBUG_PAD_NAME (pad));
2173
2174   /* activate the streams */
2175   GST_OBJECT_LOCK (src);
2176   if (!src->need_activate)
2177     goto was_ok;
2178
2179   src->need_activate = FALSE;
2180   GST_OBJECT_UNLOCK (src);
2181
2182   gst_rtspsrc_activate_streams (src);
2183
2184   return;
2185
2186 was_ok:
2187   {
2188     GST_OBJECT_UNLOCK (src);
2189     return;
2190   }
2191 }
2192
2193 /* this callback is called when the session manager generated a new src pad with
2194  * payloaded RTP packets. We simply ghost the pad here. */
2195 static void
2196 new_manager_pad (GstElement * manager, GstPad * pad, GstRTSPSrc * src)
2197 {
2198   gchar *name;
2199   GstPadTemplate *template;
2200   gint id, ssrc, pt;
2201   GList *lstream;
2202   GstRTSPStream *stream;
2203   gboolean all_added;
2204
2205   GST_DEBUG_OBJECT (src, "got new manager pad %" GST_PTR_FORMAT, pad);
2206
2207   GST_RTSP_STATE_LOCK (src);
2208   /* find stream */
2209   name = gst_object_get_name (GST_OBJECT_CAST (pad));
2210   if (sscanf (name, "recv_rtp_src_%d_%d_%d", &id, &ssrc, &pt) != 3)
2211     goto unknown_stream;
2212
2213   GST_DEBUG_OBJECT (src, "stream: %u, SSRC %d, PT %d", id, ssrc, pt);
2214
2215   stream = find_stream (src, &id, (gpointer) find_stream_by_id);
2216   if (stream == NULL)
2217     goto unknown_stream;
2218
2219   /* create a new pad we will use to stream to */
2220   template = gst_static_pad_template_get (&rtptemplate);
2221   stream->srcpad = gst_ghost_pad_new_from_template (name, pad, template);
2222   gst_object_unref (template);
2223   g_free (name);
2224
2225   stream->added = TRUE;
2226   gst_pad_set_event_function (stream->srcpad, gst_rtspsrc_handle_src_event);
2227   gst_pad_set_query_function (stream->srcpad, gst_rtspsrc_handle_src_query);
2228   gst_pad_set_active (stream->srcpad, TRUE);
2229   gst_element_add_pad (GST_ELEMENT_CAST (src), stream->srcpad);
2230
2231   /* check if we added all streams */
2232   all_added = TRUE;
2233   for (lstream = src->streams; lstream; lstream = g_list_next (lstream)) {
2234     stream = (GstRTSPStream *) lstream->data;
2235
2236     GST_DEBUG_OBJECT (src, "stream %p, container %d, disabled %d, added %d",
2237         stream, stream->container, stream->disabled, stream->added);
2238
2239     /* a container stream only needs one pad added. Also disabled streams don't
2240      * count */
2241     if (!stream->container && !stream->disabled && !stream->added) {
2242       all_added = FALSE;
2243       break;
2244     }
2245   }
2246   GST_RTSP_STATE_UNLOCK (src);
2247
2248   if (all_added) {
2249     GST_DEBUG_OBJECT (src, "We added all streams");
2250     /* when we get here, all stream are added and we can fire the no-more-pads
2251      * signal. */
2252     gst_element_no_more_pads (GST_ELEMENT_CAST (src));
2253   }
2254
2255   return;
2256
2257   /* ERRORS */
2258 unknown_stream:
2259   {
2260     GST_DEBUG_OBJECT (src, "ignoring unknown stream");
2261     GST_RTSP_STATE_UNLOCK (src);
2262     g_free (name);
2263     return;
2264   }
2265 }
2266
2267 static GstCaps *
2268 request_pt_map (GstElement * manager, guint session, guint pt, GstRTSPSrc * src)
2269 {
2270   GstRTSPStream *stream;
2271   GstCaps *caps;
2272
2273   GST_DEBUG_OBJECT (src, "getting pt map for pt %d in session %d", pt, session);
2274
2275   GST_RTSP_STATE_LOCK (src);
2276   stream = find_stream (src, &session, (gpointer) find_stream_by_id);
2277   if (!stream)
2278     goto unknown_stream;
2279
2280   caps = stream->caps;
2281   if (caps)
2282     gst_caps_ref (caps);
2283   GST_RTSP_STATE_UNLOCK (src);
2284
2285   return caps;
2286
2287 unknown_stream:
2288   {
2289     GST_DEBUG_OBJECT (src, "unknown stream %d", session);
2290     GST_RTSP_STATE_UNLOCK (src);
2291     return NULL;
2292   }
2293 }
2294
2295 static void
2296 gst_rtspsrc_do_stream_eos (GstRTSPSrc * src, GstRTSPStream * stream)
2297 {
2298   GST_DEBUG_OBJECT (src, "setting stream for session %u to EOS", stream->id);
2299
2300   if (stream->eos)
2301     goto was_eos;
2302
2303   stream->eos = TRUE;
2304   gst_rtspsrc_stream_push_event (src, stream, gst_event_new_eos (), TRUE);
2305   return;
2306
2307   /* ERRORS */
2308 was_eos:
2309   {
2310     GST_DEBUG_OBJECT (src, "stream for session %u was already EOS", stream->id);
2311     return;
2312   }
2313 }
2314
2315 static void
2316 on_bye_ssrc (GObject * session, GObject * source, GstRTSPStream * stream)
2317 {
2318   GstRTSPSrc *src = stream->parent;
2319
2320   GST_DEBUG_OBJECT (src, "source in session %u received BYE", stream->id);
2321
2322   gst_rtspsrc_do_stream_eos (src, stream);
2323 }
2324
2325 static void
2326 on_timeout (GObject * session, GObject * source, GstRTSPStream * stream)
2327 {
2328   GstRTSPSrc *src = stream->parent;
2329
2330   GST_DEBUG_OBJECT (src, "source in session %u timed out", stream->id);
2331
2332   gst_rtspsrc_do_stream_eos (src, stream);
2333 }
2334
2335 static void
2336 on_npt_stop (GstElement * rtpbin, guint session, guint ssrc, GstRTSPSrc * src)
2337 {
2338   GstRTSPStream *stream;
2339
2340   GST_DEBUG_OBJECT (src, "source in session %u reached NPT stop", session);
2341
2342   /* get stream for session */
2343   stream = find_stream (src, &session, (gpointer) find_stream_by_id);
2344   if (stream) {
2345     gst_rtspsrc_do_stream_eos (src, stream);
2346   }
2347 }
2348
2349 static void
2350 on_ssrc_active (GObject * session, GObject * source, GstRTSPStream * stream)
2351 {
2352   GST_DEBUG_OBJECT (stream->parent, "source in session %u is active",
2353       stream->id);
2354 }
2355
2356 /* try to get and configure a manager */
2357 static gboolean
2358 gst_rtspsrc_stream_configure_manager (GstRTSPSrc * src, GstRTSPStream * stream,
2359     GstRTSPTransport * transport)
2360 {
2361   const gchar *manager;
2362   gchar *name;
2363   GstStateChangeReturn ret;
2364
2365   /* find a manager */
2366   if (gst_rtsp_transport_get_manager (transport->trans, &manager, 0) < 0)
2367     goto no_manager;
2368
2369   if (manager) {
2370     GST_DEBUG_OBJECT (src, "using manager %s", manager);
2371
2372     /* configure the manager */
2373     if (src->manager == NULL) {
2374       GObjectClass *klass;
2375       GstState target;
2376
2377       if (!(src->manager = gst_element_factory_make (manager, NULL))) {
2378         /* fallback */
2379         if (gst_rtsp_transport_get_manager (transport->trans, &manager, 1) < 0)
2380           goto no_manager;
2381
2382         if (!manager)
2383           goto use_no_manager;
2384
2385         if (!(src->manager = gst_element_factory_make (manager, NULL)))
2386           goto manager_failed;
2387       }
2388
2389       /* we manage this element */
2390       gst_bin_add (GST_BIN_CAST (src), src->manager);
2391
2392       GST_OBJECT_LOCK (src);
2393       target = GST_STATE_TARGET (src);
2394       GST_OBJECT_UNLOCK (src);
2395
2396       ret = gst_element_set_state (src->manager, target);
2397       if (ret == GST_STATE_CHANGE_FAILURE)
2398         goto start_manager_failure;
2399
2400       g_object_set (src->manager, "latency", src->latency, NULL);
2401
2402       klass = G_OBJECT_GET_CLASS (G_OBJECT (src->manager));
2403       if (g_object_class_find_property (klass, "buffer-mode")) {
2404         if (src->buffer_mode != BUFFER_MODE_AUTO) {
2405           g_object_set (src->manager, "buffer-mode", src->buffer_mode, NULL);
2406         } else {
2407           gboolean need_slave;
2408           GstStructure *s;
2409           const gchar *encoding;
2410
2411           /* buffer mode pauses are handled by adding offsets to buffer times,
2412            * but some depayloaders may have a hard time syncing output times
2413            * with such input times, e.g. container ones, most notably ASF */
2414           /* TODO alternatives are having an event that indicates these shifts,
2415            * or having rtsp extensions provide suggestion on buffer mode */
2416           need_slave = stream->container;
2417           if (stream->caps && (s = gst_caps_get_structure (stream->caps, 0)) &&
2418               (encoding = gst_structure_get_string (s, "encoding-name")))
2419             need_slave = need_slave || (strcmp (encoding, "X-ASF-PF") == 0);
2420           GST_DEBUG_OBJECT (src, "auto buffering mode, need_slave %d",
2421               need_slave);
2422           /* valid duration implies not likely live pipeline,
2423            * so slaving in jitterbuffer does not make much sense
2424            * (and might mess things up due to bursts) */
2425           if (GST_CLOCK_TIME_IS_VALID (src->segment.duration) &&
2426               src->segment.duration && !need_slave) {
2427             GST_DEBUG_OBJECT (src, "selected buffer");
2428             g_object_set (src->manager, "buffer-mode", BUFFER_MODE_BUFFER,
2429                 NULL);
2430           } else {
2431             GST_DEBUG_OBJECT (src, "selected slave");
2432             g_object_set (src->manager, "buffer-mode", BUFFER_MODE_SLAVE, NULL);
2433           }
2434         }
2435       }
2436
2437       /* connect to signals if we did not already do so */
2438       GST_DEBUG_OBJECT (src, "connect to signals on session manager, stream %p",
2439           stream);
2440       src->manager_sig_id =
2441           g_signal_connect (src->manager, "pad-added",
2442           (GCallback) new_manager_pad, src);
2443       src->manager_ptmap_id =
2444           g_signal_connect (src->manager, "request-pt-map",
2445           (GCallback) request_pt_map, src);
2446
2447       g_signal_connect (src->manager, "on-npt-stop", (GCallback) on_npt_stop,
2448           src);
2449     }
2450
2451     /* we stream directly to the manager, get some pads. Each RTSP stream goes
2452      * into a separate RTP session. */
2453     name = g_strdup_printf ("recv_rtp_sink_%d", stream->id);
2454     stream->channelpad[0] = gst_element_get_request_pad (src->manager, name);
2455     g_free (name);
2456     name = g_strdup_printf ("recv_rtcp_sink_%d", stream->id);
2457     stream->channelpad[1] = gst_element_get_request_pad (src->manager, name);
2458     g_free (name);
2459
2460     /* now configure the bandwidth in the manager */
2461     if (g_signal_lookup ("get-internal-session",
2462             G_OBJECT_TYPE (src->manager)) != 0) {
2463       GObject *rtpsession;
2464
2465       g_signal_emit_by_name (src->manager, "get-internal-session", stream->id,
2466           &rtpsession);
2467       if (rtpsession) {
2468         GST_INFO_OBJECT (src, "configure bandwidth in session %p", rtpsession);
2469
2470         stream->session = rtpsession;
2471
2472         if (stream->as_bandwidth != -1) {
2473           GST_INFO_OBJECT (src, "setting AS: %f",
2474               (gdouble) (stream->as_bandwidth * 1000));
2475           g_object_set (rtpsession, "bandwidth",
2476               (gdouble) (stream->as_bandwidth * 1000), NULL);
2477         }
2478         if (stream->rr_bandwidth != -1) {
2479           GST_INFO_OBJECT (src, "setting RR: %u", stream->rr_bandwidth);
2480           g_object_set (rtpsession, "rtcp-rr-bandwidth", stream->rr_bandwidth,
2481               NULL);
2482         }
2483         if (stream->rs_bandwidth != -1) {
2484           GST_INFO_OBJECT (src, "setting RS: %u", stream->rs_bandwidth);
2485           g_object_set (rtpsession, "rtcp-rs-bandwidth", stream->rs_bandwidth,
2486               NULL);
2487         }
2488         g_signal_connect (rtpsession, "on-bye-ssrc", (GCallback) on_bye_ssrc,
2489             stream);
2490         g_signal_connect (rtpsession, "on-bye-timeout", (GCallback) on_timeout,
2491             stream);
2492         g_signal_connect (rtpsession, "on-timeout", (GCallback) on_timeout,
2493             stream);
2494         g_signal_connect (rtpsession, "on-ssrc-active",
2495             (GCallback) on_ssrc_active, stream);
2496       }
2497     }
2498   }
2499
2500 use_no_manager:
2501   return TRUE;
2502
2503   /* ERRORS */
2504 no_manager:
2505   {
2506     GST_DEBUG_OBJECT (src, "cannot get a session manager");
2507     return FALSE;
2508   }
2509 manager_failed:
2510   {
2511     GST_DEBUG_OBJECT (src, "no session manager element %s found", manager);
2512     return FALSE;
2513   }
2514 start_manager_failure:
2515   {
2516     GST_DEBUG_OBJECT (src, "could not start session manager");
2517     return FALSE;
2518   }
2519 }
2520
2521 /* free the UDP sources allocated when negotiating a transport.
2522  * This function is called when the server negotiated to a transport where the
2523  * UDP sources are not needed anymore, such as TCP or multicast. */
2524 static void
2525 gst_rtspsrc_stream_free_udp (GstRTSPStream * stream)
2526 {
2527   gint i;
2528
2529   for (i = 0; i < 2; i++) {
2530     if (stream->udpsrc[i]) {
2531       gst_element_set_state (stream->udpsrc[i], GST_STATE_NULL);
2532       gst_object_unref (stream->udpsrc[i]);
2533       stream->udpsrc[i] = NULL;
2534     }
2535   }
2536 }
2537
2538 /* for TCP, create pads to send and receive data to and from the manager and to
2539  * intercept various events and queries
2540  */
2541 static gboolean
2542 gst_rtspsrc_stream_configure_tcp (GstRTSPSrc * src, GstRTSPStream * stream,
2543     GstRTSPTransport * transport, GstPad ** outpad)
2544 {
2545   gchar *name;
2546   GstPadTemplate *template;
2547   GstPad *pad0, *pad1;
2548
2549   /* configure for interleaved delivery, nothing needs to be done
2550    * here, the loop function will call the chain functions of the
2551    * session manager. */
2552   stream->channel[0] = transport->interleaved.min;
2553   stream->channel[1] = transport->interleaved.max;
2554   GST_DEBUG_OBJECT (src, "stream %p on channels %d-%d", stream,
2555       stream->channel[0], stream->channel[1]);
2556
2557   /* we can remove the allocated UDP ports now */
2558   gst_rtspsrc_stream_free_udp (stream);
2559
2560   /* no session manager, send data to srcpad directly */
2561   if (!stream->channelpad[0]) {
2562     GST_DEBUG_OBJECT (src, "no manager, creating pad");
2563
2564     /* create a new pad we will use to stream to */
2565     name = g_strdup_printf ("stream%d", stream->id);
2566     template = gst_static_pad_template_get (&rtptemplate);
2567     stream->channelpad[0] = gst_pad_new_from_template (template, name);
2568     gst_object_unref (template);
2569     g_free (name);
2570
2571     /* set caps and activate */
2572     gst_pad_use_fixed_caps (stream->channelpad[0]);
2573     gst_pad_set_active (stream->channelpad[0], TRUE);
2574
2575     *outpad = gst_object_ref (stream->channelpad[0]);
2576   } else {
2577     GST_DEBUG_OBJECT (src, "using manager source pad");
2578
2579     template = gst_static_pad_template_get (&anysrctemplate);
2580
2581     /* allocate pads for sending the channel data into the manager */
2582     pad0 = gst_pad_new_from_template (template, "internalsrc0");
2583     gst_pad_link (pad0, stream->channelpad[0]);
2584     gst_object_unref (stream->channelpad[0]);
2585     stream->channelpad[0] = pad0;
2586     gst_pad_set_event_function (pad0, gst_rtspsrc_handle_internal_src_event);
2587     gst_pad_set_query_function (pad0, gst_rtspsrc_handle_internal_src_query);
2588     gst_pad_set_element_private (pad0, src);
2589     gst_pad_set_active (pad0, TRUE);
2590
2591     if (stream->channelpad[1]) {
2592       /* if we have a sinkpad for the other channel, create a pad and link to the
2593        * manager. */
2594       pad1 = gst_pad_new_from_template (template, "internalsrc1");
2595       gst_pad_set_event_function (pad1, gst_rtspsrc_handle_internal_src_event);
2596       gst_pad_link (pad1, stream->channelpad[1]);
2597       gst_object_unref (stream->channelpad[1]);
2598       stream->channelpad[1] = pad1;
2599       gst_pad_set_active (pad1, TRUE);
2600     }
2601     gst_object_unref (template);
2602   }
2603   /* setup RTCP transport back to the server if we have to. */
2604   if (src->manager && src->do_rtcp) {
2605     GstPad *pad;
2606
2607     template = gst_static_pad_template_get (&anysinktemplate);
2608
2609     stream->rtcppad = gst_pad_new_from_template (template, "internalsink0");
2610     gst_pad_set_chain_function (stream->rtcppad, gst_rtspsrc_sink_chain);
2611     gst_pad_set_element_private (stream->rtcppad, stream);
2612     gst_pad_set_active (stream->rtcppad, TRUE);
2613
2614     /* get session RTCP pad */
2615     name = g_strdup_printf ("send_rtcp_src_%d", stream->id);
2616     pad = gst_element_get_request_pad (src->manager, name);
2617     g_free (name);
2618
2619     /* and link */
2620     if (pad) {
2621       gst_pad_link (pad, stream->rtcppad);
2622       gst_object_unref (pad);
2623     }
2624
2625     gst_object_unref (template);
2626   }
2627   return TRUE;
2628 }
2629
2630 static void
2631 gst_rtspsrc_get_transport_info (GstRTSPSrc * src, GstRTSPStream * stream,
2632     GstRTSPTransport * transport, const gchar ** destination, gint * min,
2633     gint * max, guint * ttl)
2634 {
2635   if (transport->lower_transport == GST_RTSP_LOWER_TRANS_UDP_MCAST) {
2636     if (destination) {
2637       if (!(*destination = transport->destination))
2638         *destination = stream->destination;
2639     }
2640     if (min && max) {
2641       /* transport first */
2642       *min = transport->port.min;
2643       *max = transport->port.max;
2644       if (*min == -1 && *max == -1) {
2645         /* then try from SDP */
2646         if (stream->port != 0) {
2647           *min = stream->port;
2648           *max = stream->port + 1;
2649         }
2650       }
2651     }
2652
2653     if (ttl) {
2654       if (!(*ttl = transport->ttl))
2655         *ttl = stream->ttl;
2656     }
2657   } else {
2658     if (destination) {
2659       /* first take the source, then the endpoint to figure out where to send
2660        * the RTCP. */
2661       if (!(*destination = transport->source)) {
2662         if (src->conninfo.connection)
2663           *destination = gst_rtsp_connection_get_ip (src->conninfo.connection);
2664         else if (stream->conninfo.connection)
2665           *destination =
2666               gst_rtsp_connection_get_ip (stream->conninfo.connection);
2667       }
2668     }
2669     if (min && max) {
2670       /* for unicast we only expect the ports here */
2671       *min = transport->server_port.min;
2672       *max = transport->server_port.max;
2673     }
2674   }
2675 }
2676
2677 /* For multicast create UDP sources and join the multicast group. */
2678 static gboolean
2679 gst_rtspsrc_stream_configure_mcast (GstRTSPSrc * src, GstRTSPStream * stream,
2680     GstRTSPTransport * transport, GstPad ** outpad)
2681 {
2682   gchar *uri;
2683   const gchar *destination;
2684   gint min, max;
2685
2686   GST_DEBUG_OBJECT (src, "creating UDP sources for multicast");
2687
2688   /* we can remove the allocated UDP ports now */
2689   gst_rtspsrc_stream_free_udp (stream);
2690
2691   gst_rtspsrc_get_transport_info (src, stream, transport, &destination, &min,
2692       &max, NULL);
2693
2694   /* we need a destination now */
2695   if (destination == NULL)
2696     goto no_destination;
2697
2698   /* we really need ports now or we won't be able to receive anything at all */
2699   if (min == -1 && max == -1)
2700     goto no_ports;
2701
2702   GST_DEBUG_OBJECT (src, "have destination '%s' and ports (%d)-(%d)",
2703       destination, min, max);
2704
2705   /* creating UDP source for RTP */
2706   if (min != -1) {
2707     uri = g_strdup_printf ("udp://%s:%d", destination, min);
2708     stream->udpsrc[0] = gst_element_make_from_uri (GST_URI_SRC, uri, NULL);
2709     g_free (uri);
2710     if (stream->udpsrc[0] == NULL)
2711       goto no_element;
2712
2713     /* take ownership */
2714     gst_object_ref (stream->udpsrc[0]);
2715     gst_object_sink (stream->udpsrc[0]);
2716
2717     /* change state */
2718     gst_element_set_state (stream->udpsrc[0], GST_STATE_PAUSED);
2719   }
2720
2721   /* creating another UDP source for RTCP */
2722   if (max != -1) {
2723     uri = g_strdup_printf ("udp://%s:%d", destination, max);
2724     stream->udpsrc[1] = gst_element_make_from_uri (GST_URI_SRC, uri, NULL);
2725     g_free (uri);
2726     if (stream->udpsrc[1] == NULL)
2727       goto no_element;
2728
2729     /* take ownership */
2730     gst_object_ref (stream->udpsrc[1]);
2731     gst_object_sink (stream->udpsrc[1]);
2732
2733     gst_element_set_state (stream->udpsrc[1], GST_STATE_PAUSED);
2734   }
2735   return TRUE;
2736
2737   /* ERRORS */
2738 no_element:
2739   {
2740     GST_DEBUG_OBJECT (src, "no UDP source element found");
2741     return FALSE;
2742   }
2743 no_destination:
2744   {
2745     GST_DEBUG_OBJECT (src, "no destination found");
2746     return FALSE;
2747   }
2748 no_ports:
2749   {
2750     GST_DEBUG_OBJECT (src, "no ports found");
2751     return FALSE;
2752   }
2753 }
2754
2755 /* configure the remainder of the UDP ports */
2756 static gboolean
2757 gst_rtspsrc_stream_configure_udp (GstRTSPSrc * src, GstRTSPStream * stream,
2758     GstRTSPTransport * transport, GstPad ** outpad)
2759 {
2760   /* we manage the UDP elements now. For unicast, the UDP sources where
2761    * allocated in the stream when we suggested a transport. */
2762   if (stream->udpsrc[0]) {
2763     gst_bin_add (GST_BIN_CAST (src), stream->udpsrc[0]);
2764
2765     GST_DEBUG_OBJECT (src, "setting up UDP source");
2766
2767     /* configure a timeout on the UDP port. When the timeout message is
2768      * posted, we assume UDP transport is not possible. We reconnect using TCP
2769      * if we can. */
2770     g_object_set (G_OBJECT (stream->udpsrc[0]), "timeout", src->udp_timeout,
2771         NULL);
2772
2773     /* get output pad of the UDP source. */
2774     *outpad = gst_element_get_static_pad (stream->udpsrc[0], "src");
2775
2776     /* save it so we can unblock */
2777     stream->blockedpad = *outpad;
2778
2779     /* configure pad block on the pad. As soon as there is dataflow on the
2780      * UDP source, we know that UDP is not blocked by a firewall and we can
2781      * configure all the streams to let the application autoplug decoders. */
2782     gst_pad_set_blocked_async (stream->blockedpad, TRUE,
2783         (GstPadBlockCallback) pad_blocked, src);
2784
2785     if (stream->channelpad[0]) {
2786       GST_DEBUG_OBJECT (src, "connecting UDP source 0 to manager");
2787       /* configure for UDP delivery, we need to connect the UDP pads to
2788        * the session plugin. */
2789       gst_pad_link (*outpad, stream->channelpad[0]);
2790       gst_object_unref (*outpad);
2791       *outpad = NULL;
2792       /* we connected to pad-added signal to get pads from the manager */
2793     } else {
2794       GST_DEBUG_OBJECT (src, "using UDP src pad as output");
2795     }
2796   }