?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
input: change rate argument
[vlc.git] / modules / access / live555.cpp
blobd72a8fbd963e3867115100eef3e6660f89b09e57
1 /*****************************************************************************
2 * live555.cpp : LIVE555 Streaming Media support.
3 *****************************************************************************
4 * Copyright (C) 2003-2007 VLC authors and VideoLAN
5 *
6 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7 * Derk-Jan Hartman <hartman at videolan. org>
8 * Derk-Jan Hartman <djhartman at m2x .dot. nl> for M2X
9 * Sébastien Escudier <sebastien-devel celeos eu>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License as published by
13 * the Free Software Foundation; either version 2.1 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * along with this program; if not, write to the Free Software Foundation,
23 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 *****************************************************************************/
25
26 /*****************************************************************************
27 * Preamble
28 *****************************************************************************/
29
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <inttypes.h>
35
36 #include <vlc_common.h>
37 #include <vlc_plugin.h>
38 #include <vlc_input.h>
39 #include <vlc_demux.h>
40 #include <vlc_dialog.h>
41 #include <vlc_url.h>
42 #include <vlc_strings.h>
43 #include <vlc_interrupt.h>
44 #include <vlc_keystore.h>
45 #include <vlc_threads.h>
46 #include <vlc_cxx_helpers.hpp>
47
48 #include <limits.h>
49 #include <assert.h>
50
51 #include <new>
52
53 #if defined( _WIN32 )
54 # include <winsock2.h>
55 #endif
56
57 #include <UsageEnvironment.hh>
58 #include <BasicUsageEnvironment.hh>
59 #include <GroupsockHelper.hh>
60 #include <liveMedia.hh>
61 #include <liveMedia_version.hh>
62 #include <Base64.hh>
63
64 extern "C" {
65 #include "../access/mms/asf.h" /* Who said ugly ? */
66 #include "live555_dtsgen.h"
67 }
68
69 /*****************************************************************************
70 * Module descriptor
71 *****************************************************************************/
72 static int Open ( vlc_object_t * );
73 static void Close( vlc_object_t * );
74
75 #define KASENNA_TEXT N_( "Kasenna RTSP dialect")
76 #define KASENNA_LONGTEXT N_( "Kasenna servers use an old and nonstandard " \
77 "dialect of RTSP. With this parameter VLC will try this dialect, but "\
78 "then it cannot connect to normal RTSP servers." )
79
80 #define WMSERVER_TEXT N_("WMServer RTSP dialect")
81 #define WMSERVER_LONGTEXT N_("WMServer uses a nonstandard dialect " \
82 "of RTSP. Selecting this parameter will tell VLC to assume some " \
83 "options contrary to RFC 2326 guidelines.")
84
85 #define USER_TEXT N_("Username")
86 #define USER_LONGTEXT N_("Sets the username for the connection, " \
87 "if no username or password are set in the url.")
88 #define PASS_TEXT N_("Password")
89 #define PASS_LONGTEXT N_("Sets the password for the connection, " \
90 "if no username or password are set in the url.")
91 #define FRAME_BUFFER_SIZE_TEXT N_("RTSP frame buffer size")
92 #define FRAME_BUFFER_SIZE_LONGTEXT N_("RTSP start frame buffer size of the video " \
93 "track, can be increased in case of broken pictures due " \
94 "to too small buffer.")
95 #define DEFAULT_FRAME_BUFFER_SIZE 250000
96
97 vlc_module_begin ()
98 set_description( N_("RTP/RTSP/SDP demuxer (using Live555)" ) )
99 set_capability( "demux", 50 )
100 set_shortname( "RTP/RTSP")
101 set_callbacks( Open, Close )
102 add_shortcut( "live", "livedotcom" )
103 set_category( CAT_INPUT )
104 set_subcategory( SUBCAT_INPUT_DEMUX )
105
106 add_submodule ()
107 set_description( N_("RTSP/RTP access and demux") )
108 add_shortcut( "rtsp", "pnm", "live", "livedotcom" )
109 set_capability( "access", 300 )
110 set_callbacks( Open, Close )
111 add_bool( "rtsp-tcp", false,
112 N_("Use RTP over RTSP (TCP)"),
113 N_("Use RTP over RTSP (TCP)"), true )
114 change_safe()
115 add_integer( "rtp-client-port", -1,
116 N_("Client port"),
117 N_("Port to use for the RTP source of the session"), true )
118 add_bool( "rtsp-mcast", false,
119 N_("Force multicast RTP via RTSP"),
120 N_("Force multicast RTP via RTSP"), true )
121 change_safe()
122 add_bool( "rtsp-http", false,
123 N_("Tunnel RTSP and RTP over HTTP"),
124 N_("Tunnel RTSP and RTP over HTTP"), true )
125 change_safe()
126 add_integer( "rtsp-http-port", 80,
127 N_("HTTP tunnel port"),
128 N_("Port to use for tunneling the RTSP/RTP over HTTP."),
129 true )
130 add_bool( "rtsp-kasenna", false, KASENNA_TEXT,
131 KASENNA_LONGTEXT, true )
132 change_safe()
133 add_bool( "rtsp-wmserver", false, WMSERVER_TEXT,
134 WMSERVER_LONGTEXT, true)
135 change_safe()
136 add_string( "rtsp-user", NULL, USER_TEXT,
137 USER_LONGTEXT, true )
138 change_safe()
139 add_password("rtsp-pwd", NULL, PASS_TEXT, PASS_LONGTEXT)
140 add_integer( "rtsp-frame-buffer-size", DEFAULT_FRAME_BUFFER_SIZE,
141 FRAME_BUFFER_SIZE_TEXT, FRAME_BUFFER_SIZE_LONGTEXT,
142 true )
143 vlc_module_end ()
144
145
146 /*****************************************************************************
147 * Local prototypes
148 *****************************************************************************/
149
150 namespace {
151
152 typedef struct
153 {
154 demux_t *p_demux;
155 MediaSubsession *sub;
156
157 es_format_t fmt;
158 es_out_id_t *p_es;
159
160 enum
161 {
162 SINGLE_STREAM,
163 MULTIPLEXED_STREAM,
164 QUICKTIME_STREAM,
165 ASF_STREAM
166 } format;
167
168 block_t *p_asf_block;
169 bool b_discard_trunc;
170 vlc_demux_chained_t *p_out_muxed; /* for muxed stream */
171
172 uint8_t *p_buffer;
173 unsigned int i_buffer;
174
175 bool b_rtcp_sync;
176 bool b_flushing_discontinuity;
177 int i_next_block_flags;
178 char waiting;
179 vlc_tick_t i_prevpts;
180 vlc_tick_t i_pcr;
181 double f_npt;
182
183 struct dtsgen_t dtsgen;
184
185 enum
186 {
187 STATE_NONE,
188 STATE_SELECTED,
189 STATE_IGNORED,
190 STATE_TEARDOWN,
191 } state;
192
193 } live_track_t;
194
195 class RTSPClientVlc;
196
197 #define CAP_RATE_CONTROL (1 << 1)
198 #define CAP_SUBSESSION_TEARDOWN (1 << 2)
199 #define CAP_SUBSESSION_PAUSE (1 << 3)
200 #define CAPS_DEFAULT CAP_RATE_CONTROL
201
202 struct demux_sys_t
203 {
204 char *p_sdp; /* XXX mallocated */
205 char *psz_pl_url; /* password-less URL */
206 vlc_url_t url;
207
208 MediaSession *ms;
209 TaskScheduler *scheduler;
210 UsageEnvironment *env ;
211 RTSPClientVlc *rtsp;
212 int capabilities; /* Server capabilities workaround */
213
214 /* */
215 int i_track;
216 live_track_t **track;
217
218 /* Weird formats */
219 asf_header_t asfh;
220 vlc_demux_chained_t *p_out_asf;
221 bool b_real;
222
223 /* */
224 vlc_tick_t i_pcr; /* The clock */
225 bool b_rtcp_sync; /* At least one track received sync */
226 double f_npt;
227 double f_npt_length;
228 double f_npt_start;
229
230 /* timeout thread information */
231 vlc_timer_t timer;
232 vlc::threads::mutex timeout_mutex; /* Serialise calls to live555 in timeout thread w.r.t. Demux()/Control() */
233
234 /* */
235 bool b_force_mcast;
236 bool b_multicast; /* if one of the tracks is multicasted */
237 bool b_no_data; /* if we never received any data */
238 int i_no_data_ti; /* consecutive number of TaskInterrupt */
239
240 char event_rtsp;
241 char event_data;
242
243 bool b_get_param; /* Does the server support GET_PARAMETER */
244 bool b_paused; /* Are we paused? */
245 bool b_error;
246 int i_live555_ret; /* live555 callback return code */
247
248 float f_seek_request;/* In case we receive a seek request while paused*/
249 };
250
251
252 class RTSPClientVlc : public RTSPClient
253 {
254 public:
255 RTSPClientVlc( UsageEnvironment& env, char const* rtspURL, int verbosityLevel,
256 char const* applicationName, portNumBits tunnelOverHTTPPortNum,
257 demux_sys_t *p_sys) :
258 RTSPClient( env, rtspURL, verbosityLevel, applicationName,
259 tunnelOverHTTPPortNum
260 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1373932800
261 , -1
262 #endif
263 )
264 {
265 this->p_sys = p_sys;
266 }
267 demux_sys_t *p_sys;
268 };
269
270 } // namespace
271
272 static int Demux ( demux_t * );
273 static int Control( demux_t *, int, va_list );
274
275 static int Connect ( demux_t * );
276 static int SessionsSetup( demux_t * );
277 static int Play ( demux_t *);
278 static int ParseASF ( demux_t * );
279 static int RollOverTcp ( demux_t * );
280
281 static void StreamRead ( void *, unsigned int, unsigned int,
282 struct timeval, unsigned int );
283 static void StreamClose ( void * );
284 static void TaskInterruptData( void * );
285 static void TaskInterruptRTSP( void * );
286
287 static void TimeoutPrevention( void * );
288
289 static unsigned char* parseH264ConfigStr( char const* configStr,
290 unsigned int& configSize );
291 static unsigned char* parseVorbisConfigStr( char const* configStr,
292 unsigned int& configSize );
293
294 static char *passwordLessURL( vlc_url_t *url );
295
296 #define PCR_OBS VLC_TICK_FROM_MS(250)
297 #define PCR_OFF PCR_OBS
298
299 /*****************************************************************************
300 * DemuxOpen:
301 *****************************************************************************/
302 static int Open ( vlc_object_t *p_this )
303 {
304 demux_t *p_demux = (demux_t*)p_this;
305 demux_sys_t *p_sys = NULL;
306
307 int i_return;
308 int i_error = VLC_EGENERIC;
309
310 if (p_demux->out == NULL)
311 return VLC_EGENERIC;
312
313 /* if the rtsp URL may contain a sat.ip fake DNS, bail-out early and
314 * let the SAT>IP module handle that */
315 if( !strncmp(p_demux->psz_location, "sat.ip", 6) )
316 {
317 msg_Err( p_demux, "SAT>IP server, bailing out");
318 return VLC_EGENERIC;
319 }
320 /* If satip-host is set on the item, we shall assume it is a rtsp for the
321 * SAT>IP module and bail-out early. */
322 char *psz_host = var_InheritString(p_demux, "satip-host");
323 if (psz_host != NULL) {
324 msg_Err( p_demux, "URL is for SAT>IP, bailing out");
325 free(psz_host);
326 return VLC_EGENERIC;
327 }
328
329 if( p_demux->s )
330 {
331 /* See if it looks like a SDP
332 v, o, s fields are mandatory and in this order */
333 const uint8_t *p_peek;
334 if( vlc_stream_Peek( p_demux->s, &p_peek, 7 ) < 7 ) return VLC_EGENERIC;
335
336 if( memcmp( p_peek, "v=0\r\n", 5 ) &&
337 memcmp( p_peek, "v=0\n", 4 ) &&
338 ( p_peek[0] < 'a' || p_peek[0] > 'z' || p_peek[1] != '=' ) )
339 {
340 return VLC_EGENERIC;
341 }
342 }
343
344 p_demux->pf_demux = Demux;
345 p_demux->pf_control= Control;
346 p_demux->p_sys = p_sys = new (std::nothrow)demux_sys_t();
347 if( !p_sys ) return VLC_ENOMEM;
348
349 if( vlc_timer_create(&p_sys->timer, TimeoutPrevention, p_demux) )
350 {
351 delete p_sys;
352 return VLC_ENOMEM;
353 }
354
355 msg_Dbg( p_demux, "version " LIVEMEDIA_LIBRARY_VERSION_STRING );
356
357 p_sys->capabilities = CAPS_DEFAULT;
358 if( var_GetBool( p_demux, "rtsp-kasenna" ) ||
359 var_GetBool( p_demux, "rtsp-wmserver" ) )
360 {
361 p_sys->capabilities &= ~CAP_RATE_CONTROL;
362 }
363
364 TAB_INIT( p_sys->i_track, p_sys->track );
365 p_sys->b_no_data = true;
366 p_sys->b_force_mcast = var_InheritBool( p_demux, "rtsp-mcast" );
367 p_sys->f_seek_request = -1;
368
369 /* parse URL for rtsp://[user:[passwd]@]serverip:port/options */
370 vlc_UrlParse( &p_sys->url, p_demux->psz_url );
371
372 if( ( p_sys->psz_pl_url = passwordLessURL( &p_sys->url ) ) == NULL )
373 {
374 i_error = VLC_ENOMEM;
375 goto error;
376 }
377
378 if( ( p_sys->scheduler = BasicTaskScheduler::createNew() ) == NULL )
379 {
380 msg_Err( p_demux, "BasicTaskScheduler::createNew failed" );
381 goto error;
382 }
383 if( !( p_sys->env = BasicUsageEnvironment::createNew(*p_sys->scheduler) ) )
384 {
385 msg_Err( p_demux, "BasicUsageEnvironment::createNew failed" );
386 goto error;
387 }
388
389 if( p_demux->s != NULL )
390 {
391 char *p = p_sys->psz_pl_url;
392 while( (p = strchr( p, ' ' )) != NULL ) *p = '+';
393 }
394
395 if( p_demux->s != NULL )
396 {
397 /* Gather the complete sdp file */
398 int i_sdp = 0;
399 int i_sdp_max = 1000;
400 uint8_t *p_sdp = (uint8_t*) malloc( i_sdp_max );
401
402 if( !p_sdp )
403 {
404 i_error = VLC_ENOMEM;
405 goto error;
406 }
407
408 for( ;; )
409 {
410 int i_read = vlc_stream_Read( p_demux->s, &p_sdp[i_sdp],
411 i_sdp_max - i_sdp - 1 );
412 if( i_read < 0 )
413 {
414 msg_Err( p_demux, "failed to read SDP" );
415 free( p_sdp );
416 goto error;
417 }
418
419 i_sdp += i_read;
420
421 if( i_read < i_sdp_max - i_sdp - 1 )
422 {
423 p_sdp[i_sdp] = '\0';
424 break;
425 }
426
427 i_sdp_max += 1000;
428 p_sdp = (uint8_t*)xrealloc( p_sdp, i_sdp_max );
429 }
430 p_sys->p_sdp = (char*)p_sdp;
431 }
432 else if( ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
433 {
434 msg_Err( p_demux, "Failed to connect with %s", p_sys->psz_pl_url );
435 goto error;
436 }
437
438 if( p_sys->p_sdp == NULL )
439 {
440 msg_Err( p_demux, "Failed to retrieve the RTSP Session Description" );
441 i_error = VLC_ENOMEM;
442 goto error;
443 }
444
445 if( ( i_return = SessionsSetup( p_demux ) ) != VLC_SUCCESS )
446 {
447 msg_Err( p_demux, "Nothing to play for %s", p_sys->psz_pl_url );
448 goto error;
449 }
450
451 if( p_sys->b_real ) goto error;
452
453 if( ( i_return = Play( p_demux ) ) != VLC_SUCCESS )
454 goto error;
455
456 if( p_sys->p_out_asf && ParseASF( p_demux ) )
457 {
458 msg_Err( p_demux, "cannot find a usable asf header" );
459 /* TODO Clean tracks */
460 goto error;
461 }
462
463 if( p_sys->i_track <= 0 )
464 goto error;
465
466 return VLC_SUCCESS;
467
468 error:
469 Close( p_this );
470 return i_error;
471 }
472
473 /*****************************************************************************
474 * DemuxClose:
475 *****************************************************************************/
476 static void Close( vlc_object_t *p_this )
477 {
478 demux_t *p_demux = (demux_t*)p_this;
479 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
480
481 vlc_timer_destroy(p_sys->timer);
482
483 if( p_sys->rtsp && p_sys->ms ) p_sys->rtsp->sendTeardownCommand( *p_sys->ms, NULL );
484 if( p_sys->ms ) Medium::close( p_sys->ms );
485 if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
486 if( p_sys->env ) p_sys->env->reclaim();
487
488 for( int i = 0; i < p_sys->i_track; i++ )
489 {
490 live_track_t *tk = p_sys->track[i];
491
492 if( tk->p_out_muxed )
493 vlc_demux_chained_Delete( tk->p_out_muxed );
494 es_format_Clean( &tk->fmt );
495 dtsgen_Clean( &tk->dtsgen );
496 free( tk->p_buffer );
497 free( tk );
498 }
499 TAB_CLEAN( p_sys->i_track, p_sys->track );
500 if( p_sys->p_out_asf )
501 vlc_demux_chained_Delete( p_sys->p_out_asf );
502 delete p_sys->scheduler;
503 free( p_sys->p_sdp );
504 free( p_sys->psz_pl_url );
505
506 vlc_UrlClean( &p_sys->url );
507
508 delete p_sys;
509 }
510
511 static inline Boolean toBool( bool b ) { return b?True:False; } // silly, no?
512
513 static void default_live555_callback( RTSPClient* client, int result_code, char* result_string )
514 {
515 RTSPClientVlc *client_vlc = static_cast<RTSPClientVlc *> ( client );
516 demux_sys_t *p_sys = client_vlc->p_sys;
517 delete []result_string;
518 p_sys->i_live555_ret = result_code;
519 p_sys->b_error = p_sys->i_live555_ret != 0;
520 p_sys->event_rtsp = 1;
521 }
522
523 /* return true if the RTSP command succeeded */
524 static bool wait_Live555_response( demux_t *p_demux, int i_timeout = 0 /* ms */ )
525 {
526 TaskToken task;
527 demux_sys_t * p_sys = (demux_sys_t *)p_demux->p_sys;
528 p_sys->event_rtsp = 0;
529 if( i_timeout > 0 )
530 {
531 /* Create a task that will be called if we wait more than timeout ms */
532 task = p_sys->scheduler->scheduleDelayedTask( i_timeout*1000,
533 TaskInterruptRTSP,
534 p_demux );
535 }
536 p_sys->event_rtsp = 0;
537 p_sys->b_error = true;
538 p_sys->i_live555_ret = 0;
539 p_sys->scheduler->doEventLoop( &p_sys->event_rtsp );
540 //here, if b_error is true and i_live555_ret = 0 we didn't receive a response
541 if( i_timeout > 0 )
542 {
543 /* remove the task */
544 p_sys->scheduler->unscheduleDelayedTask( task );
545 }
546 return !p_sys->b_error;
547 }
548
549 static void continueAfterDESCRIBE( RTSPClient* client, int result_code,
550 char* result_string )
551 {
552 RTSPClientVlc *client_vlc = static_cast<RTSPClientVlc *> ( client );
553 demux_sys_t *p_sys = client_vlc->p_sys;
554 p_sys->i_live555_ret = result_code;
555 if ( result_code == 0 )
556 {
557 char* sdpDescription = result_string;
558 free( p_sys->p_sdp );
559 p_sys->p_sdp = NULL;
560 if( sdpDescription )
561 {
562 p_sys->p_sdp = strdup( sdpDescription );
563 p_sys->b_error = false;
564 }
565 }
566 else
567 p_sys->b_error = true;
568 delete[] result_string;
569 p_sys->event_rtsp = 1;
570 #ifdef VLC_PATCH_RTSPCLIENT_SERVERSTRING
571 if( client_vlc->serverString() )
572 {
573 if( !strncmp(client_vlc->serverString(), "Kasenna", 7) ||
574 !strncmp(client_vlc->serverString(), "WMServer", 8) )
575 p_sys->capabilities &= ~CAP_RATE_CONTROL;
576 if( !strncmp(client_vlc->serverString(), "VLC/", 4) )
577 p_sys->capabilities |= (CAP_SUBSESSION_TEARDOWN|CAP_SUBSESSION_PAUSE);
578 }
579 #endif
580 }
581
582 static void continueAfterOPTIONS( RTSPClient* client, int result_code,
583 char* result_string )
584 {
585 RTSPClientVlc *client_vlc = static_cast<RTSPClientVlc *> (client);
586 demux_sys_t *p_sys = client_vlc->p_sys;
587 p_sys->b_get_param =
588 // If OPTIONS fails, assume GET_PARAMETER is not supported but
589 // still continue on with the stream. Some servers (foscam)
590 // return 501/not implemented for OPTIONS.
591 result_code == 0
592 && result_string != NULL
593 && strstr( result_string, "GET_PARAMETER" ) != NULL;
594 client->sendDescribeCommand( continueAfterDESCRIBE );
595 delete[] result_string;
596 }
597
598 /*****************************************************************************
599 * Connect: connects to the RTSP server to setup the session DESCRIBE
600 *****************************************************************************/
601 static int Connect( demux_t *p_demux )
602 {
603 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
604 Authenticator authenticator;
605 vlc_credential credential;
606 const char *psz_user = NULL;
607 const char *psz_pwd = NULL;
608 int i_http_port = 0;
609 int i_ret = VLC_SUCCESS;
610 const int i_timeout = var_InheritInteger( p_demux, "ipv4-timeout" );
611
612 vlc_credential_init( &credential, &p_sys->url );
613
614 /* Credentials can be NULL since they may not be needed */
615 if( vlc_credential_get( &credential, p_demux, "rtsp-user", "rtsp-pwd",
616 NULL, NULL) )
617 {
618 psz_user = credential.psz_username;
619 psz_pwd = credential.psz_password;
620 }
621
622 createnew:
623 /* FIXME: This is naive and incorrect; it does not prevent the thread
624 * getting stuck in blocking socket operations. */
625 if( vlc_killed() )
626 {
627 i_ret = VLC_EGENERIC;
628 goto bailout;
629 }
630
631 if( var_CreateGetBool( p_demux, "rtsp-http" ) )
632 i_http_port = var_InheritInteger( p_demux, "rtsp-http-port" );
633
634 p_sys->rtsp = new (std::nothrow) RTSPClientVlc( *p_sys->env, p_sys->psz_pl_url,
635 var_InheritInteger( p_demux, "verbose" ) > 1 ? 1 : 0,
636 "LibVLC/" VERSION, i_http_port, p_sys );
637 if( !p_sys->rtsp )
638 {
639 msg_Err( p_demux, "RTSPClient::createNew failed (%s)",
640 p_sys->env->getResultMsg() );
641 i_ret = VLC_EGENERIC;
642 goto bailout;
643 }
644
645 /* Kasenna enables KeepAlive by analysing the User-Agent string.
646 * Appending _KA to the string should be enough to enable this feature,
647 * however, there is a bug where the _KA doesn't get parsed from the
648 * default User-Agent as created by VLC/Live555 code. This is probably due
649 * to spaces in the string or the string being too long. Here we override
650 * the default string with a more compact version.
651 */
652 if( var_InheritBool( p_demux, "rtsp-kasenna" ))
653 {
654 p_sys->rtsp->setUserAgentString( "VLC_MEDIA_PLAYER_KA" );
655 }
656
657 describe:
658 authenticator.setUsernameAndPassword( psz_user, psz_pwd );
659
660 p_sys->rtsp->sendOptionsCommand( &continueAfterOPTIONS, &authenticator );
661
662 if( !wait_Live555_response( p_demux, i_timeout ) )
663 {
664 int i_code = p_sys->i_live555_ret;
665 if( i_code == 401 )
666 {
667 msg_Dbg( p_demux, "authentication failed" );
668
669 if( vlc_credential_get( &credential, p_demux, "rtsp-user", "rtsp-pwd",
670 _("RTSP authentication"),
671 _("Please enter a valid login name and a password.") ) )
672 {
673 psz_user = credential.psz_username;
674 psz_pwd = credential.psz_password;
675 msg_Dbg( p_demux, "retrying with user=%s", psz_user );
676 goto describe;
677 }
678 }
679 else if( i_code > 0 && i_code != 404 && !var_GetBool( p_demux, "rtsp-http" ) )
680 {
681 /* Perhaps a firewall is being annoying. Try HTTP tunneling mode */
682 msg_Dbg( p_demux, "we will now try HTTP tunneling mode" );
683 var_SetBool( p_demux, "rtsp-http", true );
684 if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
685 p_sys->rtsp = NULL;
686 goto createnew;
687 }
688 else
689 {
690 if( i_code == 0 )
691 msg_Dbg( p_demux, "connection timeout" );
692 else
693 {
694 msg_Dbg( p_demux, "connection error %d", i_code );
695 if( i_code == 403 )
696 vlc_dialog_display_error( p_demux, _("RTSP connection failed"),
697 _("Access to the stream is denied by the server configuration.") );
698 }
699 if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
700 p_sys->rtsp = NULL;
701 }
702 i_ret = VLC_EGENERIC;
703 }
704 else
705 vlc_credential_store( &credential, p_demux );
706
707 bailout:
708 vlc_credential_clean( &credential );
709
710 return i_ret;
711 }
712
713 /*****************************************************************************
714 * SessionsSetup: prepares the subsessions and does the SETUP
715 *****************************************************************************/
716 static int SessionsSetup( demux_t *p_demux )
717 {
718 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
719 MediaSubsessionIterator *iter = NULL;
720 MediaSubsession *sub = NULL;
721
722 bool b_rtsp_tcp;
723 int i_client_port;
724 int i_return = VLC_SUCCESS;
725 unsigned int i_receive_buffer = 0;
726 int i_frame_buffer = DEFAULT_FRAME_BUFFER_SIZE;
727 unsigned const thresh = 200000; /* RTP reorder threshold .2 second (default .1) */
728 const char *p_sess_lang = NULL;
729 const char *p_lang;
730
731 b_rtsp_tcp = var_CreateGetBool( p_demux, "rtsp-tcp" ) ||
732 var_GetBool( p_demux, "rtsp-http" );
733 i_client_port = var_InheritInteger( p_demux, "rtp-client-port" );
734
735
736 /* Create the session from the SDP */
737 if( !( p_sys->ms = MediaSession::createNew( *p_sys->env, p_sys->p_sdp ) ) )
738 {
739 msg_Err( p_demux, "Could not create the RTSP Session: %s",
740 p_sys->env->getResultMsg() );
741 return VLC_EGENERIC;
742 }
743
744 if( strcmp( p_sys->p_sdp, "m=" ) != 0 )
745 {
746 const char *p_sess_attr_end;
747
748 p_sess_attr_end = strstr( p_sys->p_sdp, "\nm=" );
749 if( !p_sess_attr_end )
750 p_sess_attr_end = strstr( p_sys->p_sdp, "\rm=" );
751
752 p_sess_lang = p_sess_attr_end ? strstr( p_sys->p_sdp, "a=lang:" ) : NULL;
753 if( p_sess_lang &&
754 p_sess_lang - p_sys->p_sdp > p_sess_attr_end - p_sys->p_sdp )
755 p_sess_lang = NULL;
756 }
757
758 /* Initialise each media subsession */
759 iter = new MediaSubsessionIterator( *p_sys->ms );
760 while( ( sub = iter->next() ) != NULL )
761 {
762 Boolean bInit;
763 live_track_t *tk;
764
765 /* Value taken from mplayer */
766 if( !strcmp( sub->mediumName(), "audio" ) )
767 i_receive_buffer = 100000;
768 else if( !strcmp( sub->mediumName(), "video" ) )
769 {
770 int i_var_buf_size = var_InheritInteger( p_demux, "rtsp-frame-buffer-size" );
771 if( i_var_buf_size > 0 )
772 i_frame_buffer = i_var_buf_size;
773 i_receive_buffer = 2000000;
774 }
775 else if( !strcmp( sub->mediumName(), "text" ) )
776 ;
777 else continue;
778
779 if( strcasestr( sub->codecName(), "REAL" ) )
780 {
781 msg_Info( p_demux, "real codec detected, using real-RTSP instead" );
782 p_sys->b_real = true; /* This is a problem, we'll handle it later */
783 continue;
784 }
785
786 if( p_sys->rtsp && i_client_port != -1 )
787 {
788 sub->setClientPortNum( i_client_port );
789 i_client_port += 2;
790 }
791
792 if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
793 bInit = sub->initiate( 0 );
794 else
795 bInit = sub->initiate();
796
797 if( !bInit )
798 {
799 msg_Warn( p_demux, "RTP subsession '%s/%s' failed (%s)",
800 sub->mediumName(), sub->codecName(),
801 p_sys->env->getResultMsg() );
802 }
803 else
804 {
805 if( sub->rtpSource() != NULL )
806 {
807 int fd = sub->rtpSource()->RTPgs()->socketNum();
808
809 /* Increase the buffer size */
810 if( i_receive_buffer > 0 )
811 increaseReceiveBufferTo( *p_sys->env, fd, i_receive_buffer );
812
813 /* Increase the RTP reorder timebuffer just a bit */
814 sub->rtpSource()->setPacketReorderingThresholdTime(thresh);
815 }
816 msg_Dbg( p_demux, "RTP subsession '%s/%s'", sub->mediumName(),
817 sub->codecName() );
818
819 /* Issue the SETUP */
820 if( p_sys->rtsp )
821 {
822 p_sys->rtsp->sendSetupCommand( *sub, default_live555_callback, False,
823 toBool( b_rtsp_tcp ),
824 toBool( p_sys->b_force_mcast && !b_rtsp_tcp ) );
825 if( !wait_Live555_response( p_demux ) )
826 {
827 /* if we get an unsupported transport error, toggle TCP
828 * use and try again */
829 if( p_sys->i_live555_ret == 461 )
830 p_sys->rtsp->sendSetupCommand( *sub, default_live555_callback, False,
831 !toBool( b_rtsp_tcp ), False );
832 if( p_sys->i_live555_ret != 461 || !wait_Live555_response( p_demux ) )
833 {
834 msg_Err( p_demux, "SETUP of'%s/%s' failed %s",
835 sub->mediumName(), sub->codecName(),
836 p_sys->env->getResultMsg() );
837 continue;
838 }
839 else
840 {
841 var_SetBool( p_demux, "rtsp-tcp", true );
842 b_rtsp_tcp = true;
843 }
844 }
845 }
846
847 /* Check if we will receive data from this subsession for
848 * this track */
849 if( sub->readSource() == NULL ) continue;
850 if( !p_sys->b_multicast )
851 {
852 /* We need different rollover behaviour for multicast */
853 p_sys->b_multicast = IsMulticastAddress( sub->connectionEndpointAddress() );
854 }
855
856 tk = (live_track_t*)malloc( sizeof( live_track_t ) );
857 if( !tk )
858 {
859 delete iter;
860 return VLC_ENOMEM;
861 }
862 tk->p_demux = p_demux;
863 tk->sub = sub;
864 tk->p_es = NULL;
865 tk->format = live_track_t::SINGLE_STREAM;
866 tk->p_asf_block = NULL;
867 tk->b_discard_trunc = false;
868 tk->p_out_muxed = NULL;
869 tk->waiting = 0;
870 tk->b_rtcp_sync = false;
871 tk->b_flushing_discontinuity = false;
872 tk->i_next_block_flags = 0;
873 tk->i_prevpts = VLC_TICK_INVALID;
874 tk->i_pcr = VLC_TICK_INVALID;
875 tk->f_npt = 0.;
876 dtsgen_Init( &tk->dtsgen );
877 tk->state = live_track_t::STATE_SELECTED;
878 tk->i_buffer = i_frame_buffer;
879 tk->p_buffer = (uint8_t *)malloc( i_frame_buffer );
880
881 if( !tk->p_buffer )
882 {
883 free( tk );
884 delete iter;
885 return VLC_ENOMEM;
886 }
887
888 /* Value taken from mplayer */
889 if( !strcmp( sub->mediumName(), "audio" ) )
890 {
891 es_format_Init( &tk->fmt, AUDIO_ES, VLC_CODEC_UNKNOWN );
892 tk->fmt.audio.i_channels = sub->numChannels();
893 tk->fmt.audio.i_rate = sub->rtpTimestampFrequency();
894
895 if( !strcmp( sub->codecName(), "MPA" ) ||
896 !strcmp( sub->codecName(), "MPA-ROBUST" ) ||
897 !strcmp( sub->codecName(), "X-MP3-DRAFT-00" ) )
898 {
899 tk->fmt.i_codec = VLC_CODEC_MPGA;
900 tk->fmt.audio.i_rate = 0;
901 }
902 else if( !strcmp( sub->codecName(), "AC3" ) )
903 {
904 tk->fmt.i_codec = VLC_CODEC_A52;
905 tk->fmt.audio.i_rate = 0;
906 }
907 else if( !strcmp( sub->codecName(), "L16" ) )
908 {
909 tk->fmt.i_codec = VLC_CODEC_S16B;
910 tk->fmt.audio.i_bitspersample = 16;
911 }
912 else if( !strcmp( sub->codecName(), "L20" ) )
913 {
914 tk->fmt.i_codec = VLC_CODEC_S20B;
915 tk->fmt.audio.i_bitspersample = 20;
916 }
917 else if( !strcmp( sub->codecName(), "L24" ) )
918 {
919 tk->fmt.i_codec = VLC_CODEC_S24B;
920 tk->fmt.audio.i_bitspersample = 24;
921 }
922 else if( !strcmp( sub->codecName(), "L8" ) )
923 {
924 tk->fmt.i_codec = VLC_CODEC_U8;
925 tk->fmt.audio.i_bitspersample = 8;
926 }
927 else if( !strcmp( sub->codecName(), "DAT12" ) )
928 {
929 tk->fmt.i_codec = VLC_CODEC_DAT12;
930 tk->fmt.audio.i_bitspersample = 12;
931 }
932 else if( !strcmp( sub->codecName(), "PCMU" ) )
933 {
934 tk->fmt.i_codec = VLC_CODEC_MULAW;
935 tk->fmt.audio.i_bitspersample = 8;
936 }
937 else if( !strcmp( sub->codecName(), "PCMA" ) )
938 {
939 tk->fmt.i_codec = VLC_CODEC_ALAW;
940 tk->fmt.audio.i_bitspersample = 8;
941 }
942 else if( !strncmp( sub->codecName(), "G726", 4 ) )
943 {
944 tk->fmt.i_codec = VLC_CODEC_ADPCM_G726;
945 tk->fmt.audio.i_rate = 8000;
946 tk->fmt.audio.i_channels = 1;
947 if( !strcmp( sub->codecName()+5, "40" ) )
948 tk->fmt.i_bitrate = 40000;
949 else if( !strcmp( sub->codecName()+5, "32" ) )
950 tk->fmt.i_bitrate = 32000;
951 else if( !strcmp( sub->codecName()+5, "24" ) )
952 tk->fmt.i_bitrate = 24000;
953 else if( !strcmp( sub->codecName()+5, "16" ) )
954 tk->fmt.i_bitrate = 16000;
955 }
956 else if( !strcmp( sub->codecName(), "AMR" ) )
957 {
958 tk->fmt.i_codec = VLC_CODEC_AMR_NB;
959 }
960 else if( !strcmp( sub->codecName(), "AMR-WB" ) )
961 {
962 tk->fmt.i_codec = VLC_CODEC_AMR_WB;
963 }
964 else if( !strcmp( sub->codecName(), "MP4A-LATM" ) )
965 {
966 unsigned int i_extra;
967 uint8_t *p_extra;
968
969 tk->fmt.i_codec = VLC_CODEC_MP4A;
970
971 if( ( p_extra = parseStreamMuxConfigStr( sub->fmtp_config(),
972 i_extra ) ) )
973 {
974 tk->fmt.i_extra = i_extra;
975 tk->fmt.p_extra = xmalloc( i_extra );
976 memcpy( tk->fmt.p_extra, p_extra, i_extra );
977 delete[] p_extra;
978 }
979 /* Because the "faad" decoder does not handle the LATM
980 * data length field at the start of each returned LATM
981 * frame, tell the RTP source to omit. */
982 ((MPEG4LATMAudioRTPSource*)sub->rtpSource())->omitLATMDataLengthField();
983 }
984 else if( !strcmp( sub->codecName(), "MPEG4-GENERIC" ) )
985 {
986 unsigned int i_extra;
987 uint8_t *p_extra;
988
989 tk->fmt.i_codec = VLC_CODEC_MP4A;
990
991 if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
992 i_extra ) ) )
993 {
994 tk->fmt.i_extra = i_extra;
995 tk->fmt.p_extra = xmalloc( i_extra );
996 memcpy( tk->fmt.p_extra, p_extra, i_extra );
997 delete[] p_extra;
998 }
999 }
1000 else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
1001 {
1002 tk->format = live_track_t::ASF_STREAM;
1003 if( p_sys->p_out_asf == NULL )
1004 p_sys->p_out_asf =
1005 vlc_demux_chained_New( VLC_OBJECT(p_demux), "asf",
1006 p_demux->out );
1007 }
1008 else if( !strcmp( sub->codecName(), "X-QT" ) ||
1009 !strcmp( sub->codecName(), "X-QUICKTIME" ) )
1010 {
1011 tk->format = live_track_t::QUICKTIME_STREAM;
1012 }
1013 else if( !strcmp( sub->codecName(), "SPEEX" ) )
1014 {
1015 tk->fmt.i_codec = VLC_FOURCC( 's', 'p', 'x', 'r' );
1016 }
1017 else if( !strcmp( sub->codecName(), "VORBIS" ) )
1018 {
1019 tk->fmt.i_codec = VLC_CODEC_VORBIS;
1020 unsigned int i_extra;
1021 unsigned char *p_extra;
1022 if( ( p_extra=parseVorbisConfigStr( sub->fmtp_config(),
1023 i_extra ) ) )
1024 {
1025 tk->fmt.i_extra = i_extra;
1026 tk->fmt.p_extra = p_extra;
1027 }
1028 else
1029 msg_Warn( p_demux,"Missing or unsupported vorbis header." );
1030 }
1031 else if( !strcmp( sub->codecName(), "OPUS" ) )
1032 {
1033 tk->fmt.i_codec = VLC_CODEC_OPUS;
1034 }
1035 }
1036 else if( !strcmp( sub->mediumName(), "video" ) )
1037 {
1038 es_format_Init( &tk->fmt, VIDEO_ES, VLC_CODEC_UNKNOWN );
1039 if( !strcmp( sub->codecName(), "MPV" ) )
1040 {
1041 tk->fmt.i_codec = VLC_CODEC_MPGV;
1042 tk->fmt.b_packetized = false;
1043 }
1044 else if( !strcmp( sub->codecName(), "H263" ) ||
1045 !strcmp( sub->codecName(), "H263-1998" ) ||
1046 !strcmp( sub->codecName(), "H263-2000" ) )
1047 {
1048 tk->fmt.i_codec = VLC_CODEC_H263;
1049 }
1050 else if( !strcmp( sub->codecName(), "H261" ) )
1051 {
1052 tk->fmt.i_codec = VLC_CODEC_H261;
1053 }
1054 else if( !strcmp( sub->codecName(), "H264" ) )
1055 {
1056 unsigned int i_extra = 0;
1057 uint8_t *p_extra = NULL;
1058
1059 tk->fmt.i_codec = VLC_CODEC_H264;
1060 tk->fmt.b_packetized = false;
1061
1062 if((p_extra=parseH264ConfigStr( sub->fmtp_spropparametersets(),
1063 i_extra ) ) )
1064 {
1065 tk->fmt.i_extra = i_extra;
1066 tk->fmt.p_extra = xmalloc( i_extra );
1067 memcpy( tk->fmt.p_extra, p_extra, i_extra );
1068
1069 delete[] p_extra;
1070 }
1071 }
1072 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1393372800 // 2014.02.26
1073 else if( !strcmp( sub->codecName(), "H265" ) )
1074 {
1075 unsigned int i_extra1 = 0, i_extra2 = 0, i_extra3 = 0, i_extraTot;
1076 uint8_t *p_extra1 = NULL, *p_extra2 = NULL, *p_extra3 = NULL;
1077
1078 tk->fmt.i_codec = VLC_CODEC_HEVC;
1079 tk->fmt.b_packetized = false;
1080
1081 p_extra1 = parseH264ConfigStr( sub->fmtp_spropvps(), i_extra1 );
1082 p_extra2 = parseH264ConfigStr( sub->fmtp_spropsps(), i_extra2 );
1083 p_extra3 = parseH264ConfigStr( sub->fmtp_sproppps(), i_extra3 );
1084 i_extraTot = i_extra1 + i_extra2 + i_extra3;
1085 if( i_extraTot > 0 )
1086 {
1087 tk->fmt.i_extra = i_extraTot;
1088 tk->fmt.p_extra = xmalloc( i_extraTot );
1089 if( p_extra1 )
1090 {
1091 memcpy( tk->fmt.p_extra, p_extra1, i_extra1 );
1092 }
1093 if( p_extra2 )
1094 {
1095 memcpy( ((char*)tk->fmt.p_extra)+i_extra1, p_extra2, i_extra2 );
1096 }
1097 if( p_extra3 )
1098 {
1099 memcpy( ((char*)tk->fmt.p_extra)+i_extra1+i_extra2, p_extra3, i_extra3 );
1100 }
1101
1102 delete[] p_extra1; delete[] p_extra2; delete[] p_extra3;
1103 }
1104 }
1105 #endif
1106 else if( !strcmp( sub->codecName(), "JPEG" ) )
1107 {
1108 tk->fmt.i_codec = VLC_CODEC_MJPG;
1109 }
1110 else if( !strcmp( sub->codecName(), "MP4V-ES" ) )
1111 {
1112 unsigned int i_extra;
1113 uint8_t *p_extra;
1114
1115 tk->fmt.i_codec = VLC_CODEC_MP4V;
1116
1117 if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
1118 i_extra ) ) )
1119 {
1120 tk->fmt.i_extra = i_extra;
1121 tk->fmt.p_extra = xmalloc( i_extra );
1122 memcpy( tk->fmt.p_extra, p_extra, i_extra );
1123 delete[] p_extra;
1124 }
1125 }
1126 else if( !strcmp( sub->codecName(), "X-QT" ) ||
1127 !strcmp( sub->codecName(), "X-QUICKTIME" ) ||
1128 !strcmp( sub->codecName(), "X-QDM" ) ||
1129 !strcmp( sub->codecName(), "X-SV3V-ES" ) ||
1130 !strcmp( sub->codecName(), "X-SORENSONVIDEO" ) )
1131 {
1132 tk->format = live_track_t::QUICKTIME_STREAM;
1133 }
1134 else if( !strcmp( sub->codecName(), "MP2T" ) )
1135 {
1136 tk->format = live_track_t::MULTIPLEXED_STREAM;
1137 tk->p_out_muxed =
1138 vlc_demux_chained_New( VLC_OBJECT(p_demux), "ts",
1139 p_demux->out );
1140 }
1141 else if( !strcmp( sub->codecName(), "MP2P" ) ||
1142 !strcmp( sub->codecName(), "MP1S" ) )
1143 {
1144 tk->format = live_track_t::MULTIPLEXED_STREAM;
1145 tk->p_out_muxed =
1146 vlc_demux_chained_New( VLC_OBJECT(p_demux), "ps",
1147 p_demux->out );
1148 }
1149 else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
1150 {
1151 tk->format = live_track_t::ASF_STREAM;
1152 if( p_sys->p_out_asf == NULL )
1153 p_sys->p_out_asf =
1154 vlc_demux_chained_New( VLC_OBJECT(p_demux),
1155 "asf", p_demux->out );
1156 }
1157 else if( !strcmp( sub->codecName(), "DV" ) )
1158 {
1159 tk->format = live_track_t::MULTIPLEXED_STREAM;
1160 tk->b_discard_trunc = true;
1161 tk->p_out_muxed =
1162 vlc_demux_chained_New( VLC_OBJECT(p_demux), "rawdv",
1163 p_demux->out );
1164 }
1165 else if( !strcmp( sub->codecName(), "VP8" ) )
1166 {
1167 tk->fmt.i_codec = VLC_CODEC_VP8;
1168 }
1169 else if( !strcmp( sub->codecName(), "THEORA" ) )
1170 {
1171 tk->fmt.i_codec = VLC_CODEC_THEORA;
1172 unsigned int i_extra;
1173 unsigned char *p_extra;
1174 if( ( p_extra=parseVorbisConfigStr( sub->fmtp_config(),
1175 i_extra ) ) )
1176 {
1177 tk->fmt.i_extra = i_extra;
1178 tk->fmt.p_extra = p_extra;
1179 }
1180 else
1181 msg_Warn( p_demux,"Missing or unsupported theora header." );
1182 }
1183 }
1184 else if( !strcmp( sub->mediumName(), "text" ) )
1185 {
1186 es_format_Init( &tk->fmt, SPU_ES, VLC_CODEC_UNKNOWN );
1187
1188 if( !strcmp( sub->codecName(), "T140" ) )
1189 {
1190 tk->fmt.i_codec = VLC_CODEC_ITU_T140;
1191 }
1192 }
1193
1194 /* Try and parse a=lang: attribute */
1195 p_lang = strstr( sub->savedSDPLines(), "a=lang:" );
1196 if( !p_lang )
1197 p_lang = p_sess_lang;
1198
1199 if( p_lang )
1200 {
1201 unsigned i_lang_len;
1202 p_lang += 7;
1203 i_lang_len = strcspn( p_lang, " \r\n" );
1204 tk->fmt.psz_language = strndup( p_lang, i_lang_len );
1205 }
1206
1207 if( tk->format == live_track_t::SINGLE_STREAM )
1208 {
1209 tk->p_es = es_out_Add( p_demux->out, &tk->fmt );
1210 }
1211
1212 if( sub->rtcpInstance() != NULL )
1213 {
1214 sub->rtcpInstance()->setByeHandler( StreamClose, tk );
1215 }
1216
1217 if( tk->p_es ||
1218 tk->format == live_track_t::QUICKTIME_STREAM ||
1219 (tk->format == live_track_t::MULTIPLEXED_STREAM && tk->p_out_muxed ) ||
1220 (tk->format == live_track_t::ASF_STREAM && p_sys->p_out_asf ) )
1221 {
1222 TAB_APPEND_CAST( (live_track_t **), p_sys->i_track, p_sys->track, tk );
1223 }
1224 else
1225 {
1226 /* BUG ??? */
1227 msg_Err( p_demux, "unusable RTSP track. this should not happen" );
1228 es_format_Clean( &tk->fmt );
1229 free( tk );
1230 }
1231 }
1232 }
1233 delete iter;
1234 if( p_sys->i_track <= 0 ) i_return = VLC_EGENERIC;
1235
1236 /* Retrieve the starttime if possible */
1237 p_sys->f_npt_start = p_sys->ms->playStartTime();
1238
1239 /* Retrieve the duration if possible */
1240 p_sys->f_npt_length = p_sys->ms->playEndTime();
1241
1242 /* */
1243 msg_Dbg( p_demux, "setup start: %f stop:%f", p_sys->f_npt_start, p_sys->f_npt_length );
1244
1245 /* */
1246 p_sys->b_no_data = true;
1247 p_sys->i_no_data_ti = 0;
1248 p_sys->b_rtcp_sync = false;
1249 p_sys->i_pcr = VLC_TICK_INVALID;
1250
1251 return i_return;
1252 }
1253
1254 /*****************************************************************************
1255 * Play: starts the actual playback of the stream
1256 *****************************************************************************/
1257 static int Play( demux_t *p_demux )
1258 {
1259 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
1260
1261 if( p_sys->rtsp )
1262 {
1263 /* The PLAY */
1264 p_sys->rtsp->sendPlayCommand( *p_sys->ms, default_live555_callback, p_sys->f_npt_start, -1, 1 );
1265
1266 if( !wait_Live555_response(p_demux) )
1267 {
1268 msg_Err( p_demux, "RTSP PLAY failed %s", p_sys->env->getResultMsg() );
1269 return VLC_EGENERIC;
1270 }
1271
1272 /* Retrieve the timeout value and set up a timeout prevention thread */
1273 int timeout = p_sys->rtsp->sessionTimeoutParameter();
1274 if( timeout <= 2 )
1275 timeout = 60; /* default value from RFC2326 */
1276 msg_Dbg( p_demux, "We have a timeout of %d seconds", timeout );
1277
1278 vlc_tick_t interval = vlc_tick_from_sec(timeout - 2);
1279 vlc_timer_schedule( p_sys->timer, false, interval, interval);
1280 }
1281 p_sys->i_pcr = VLC_TICK_INVALID;
1282
1283 /* Retrieve the starttime if possible */
1284 p_sys->f_npt_start = p_sys->ms->playStartTime();
1285 if( p_sys->ms->playEndTime() > 0 )
1286 p_sys->f_npt_length = p_sys->ms->playEndTime();
1287
1288 msg_Dbg( p_demux, "play start: %f stop:%f", p_sys->f_npt_start, p_sys->f_npt_length );
1289 return VLC_SUCCESS;
1290 }
1291
1292 /*****************************************************************************
1293 * HasSharedSession: returns if the session is shared with another stream
1294 *****************************************************************************/
1295 static bool HasSharedSession( MediaSubsession *session )
1296 {
1297 if( session->sessionId() == NULL )
1298 return false;
1299 MediaSubsessionIterator *it =
1300 new MediaSubsessionIterator( session->parentSession() );
1301 MediaSubsession *subsession;
1302 bool b_shared = false;
1303 while( (subsession = it->next()) != NULL )
1304 {
1305 if( session == subsession )
1306 continue;
1307 if( subsession->sessionId() != NULL &&
1308 !strcmp( session->sessionId(), subsession->sessionId() ) )
1309 {
1310 b_shared = true;
1311 break;
1312 }
1313 }
1314 delete it;
1315 return b_shared;
1316 }
1317
1318 /*****************************************************************************
1319 * ResumeTrack: setup or resume a silenced track
1320 *****************************************************************************/
1321 static void ResumeTrack( demux_t *p_demux, live_track_t *tk )
1322 {
1323 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
1324
1325 bool b_rtsp_tcp = var_GetBool( p_demux, "rtsp-tcp" ) ||
1326 var_GetBool( p_demux, "rtsp-http" );
1327 p_sys->rtsp->sendSetupCommand( *tk->sub, default_live555_callback, False,
1328 toBool( b_rtsp_tcp ),
1329 toBool( p_sys->b_force_mcast && !b_rtsp_tcp ) );
1330 if( !wait_Live555_response( p_demux ) )
1331 {
1332 msg_Err( p_demux, "SETUP of'%s/%s' failed %s",
1333 tk->sub->mediumName(), tk->sub->codecName(),
1334 p_sys->env->getResultMsg() );
1335 }
1336 else
1337 {
1338 p_sys->rtsp->sendPlayCommand( *tk->sub, default_live555_callback, -1, -1, p_sys->ms->scale() );
1339 if( !wait_Live555_response(p_demux) )
1340 {
1341 msg_Err( p_demux, "RTSP PLAY failed %s", p_sys->env->getResultMsg() );
1342 if( (p_sys->capabilities & CAP_SUBSESSION_TEARDOWN) ||
1343 !HasSharedSession( tk->sub ) )
1344 {
1345 tk->state = live_track_t::STATE_TEARDOWN;
1346 p_sys->rtsp->sendTeardownCommand( *tk->sub, NULL );
1347 }
1348 }
1349 else
1350 tk->state = live_track_t::STATE_SELECTED;
1351 }
1352 }
1353
1354 /*****************************************************************************
1355 * Demux:
1356 *****************************************************************************/
1357 static int Demux( demux_t *p_demux )
1358 {
1359 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
1360 TaskToken task;
1361
1362 bool b_send_pcr = true;
1363 int i;
1364
1365 /* Protect Live555 from simultaneous calls in TimeoutPrevention()
1366 during pause */
1367 vlc::threads::mutex_locker locker( p_sys->timeout_mutex );
1368
1369 for( i = 0; i < p_sys->i_track; i++ )
1370 {
1371 live_track_t *tk = p_sys->track[i];
1372
1373 if( tk->p_es )
1374 {
1375 bool b;
1376 es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, tk->p_es, &b );
1377 if( !b && (tk->state == live_track_t::STATE_SELECTED) && p_sys->rtsp )
1378 {
1379 if( (p_sys->capabilities & CAP_SUBSESSION_TEARDOWN) ||
1380 !HasSharedSession( tk->sub ) )
1381 {
1382 tk->state = live_track_t::STATE_TEARDOWN;
1383 p_sys->rtsp->sendTeardownCommand( *tk->sub, NULL );
1384 }
1385 else tk->state = live_track_t::STATE_IGNORED;
1386 }
1387 else if( b && tk->state != live_track_t::STATE_SELECTED )
1388 {
1389 if( tk->state != live_track_t::STATE_IGNORED )
1390 ResumeTrack( p_demux, tk );
1391 else
1392 tk->state = live_track_t::STATE_SELECTED;
1393
1394 if( tk->state != live_track_t::STATE_SELECTED )
1395 es_out_Control( p_demux->out, ES_OUT_SET_ES_STATE, tk->p_es, false );
1396 }
1397 }
1398
1399 if( tk->format == live_track_t::ASF_STREAM ||
1400 tk->format == live_track_t::MULTIPLEXED_STREAM )
1401 {
1402 b_send_pcr = false;
1403 }
1404 }
1405
1406 /* First warn we want to read data */
1407 p_sys->event_data = 0;
1408 for( i = 0; i < p_sys->i_track; i++ )
1409 {
1410 live_track_t *tk = p_sys->track[i];
1411
1412 if( tk->waiting == 0 )
1413 {
1414 tk->waiting = 1;
1415 tk->sub->readSource()->getNextFrame( tk->p_buffer, tk->i_buffer,
1416 StreamRead, tk, StreamClose, tk );
1417 }
1418 }
1419 /* Create a task that will be called if we wait more than 300ms */
1420 task = p_sys->scheduler->scheduleDelayedTask( 300000, TaskInterruptData, p_demux );
1421
1422 /* Do the read */
1423 p_sys->scheduler->doEventLoop( &p_sys->event_data );
1424
1425 /* remove the task */
1426 p_sys->scheduler->unscheduleDelayedTask( task );
1427
1428 if( b_send_pcr )
1429 {
1430 vlc_tick_t i_minpcr = VLC_TICK_INVALID;
1431 bool b_need_flush = false;
1432
1433 /* Check for gap in pts value */
1434 for( i = 0; i < p_sys->i_track; i++ )
1435 {
1436 live_track_t *tk = p_sys->track[i];
1437
1438 if( tk->state != live_track_t::STATE_SELECTED ||
1439 (p_sys->b_rtcp_sync && !tk->b_rtcp_sync) )
1440 continue;
1441
1442 /* Check for gap in pts value */
1443 b_need_flush |= (tk->b_flushing_discontinuity);
1444
1445 if( i_minpcr == VLC_TICK_INVALID || ( tk->i_pcr != VLC_TICK_INVALID && i_minpcr > tk->i_pcr ) )
1446 i_minpcr = tk->i_pcr;
1447 }
1448
1449 if( p_sys->i_pcr != VLC_TICK_INVALID && b_need_flush )
1450 {
1451 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
1452 p_sys->i_pcr = i_minpcr;
1453 p_sys->f_npt = 0.;
1454
1455 for( i = 0; i < p_sys->i_track; i++ )
1456 {
1457 live_track_t *tk = p_sys->track[i];
1458 tk->i_prevpts = VLC_TICK_INVALID;
1459 tk->i_pcr = VLC_TICK_INVALID;
1460 tk->f_npt = 0.;
1461 tk->b_flushing_discontinuity = false;
1462 tk->i_next_block_flags |= BLOCK_FLAG_DISCONTINUITY;
1463 }
1464 if( p_sys->i_pcr != VLC_TICK_INVALID )
1465 es_out_SetPCR( p_demux->out, VLC_TICK_0 +
1466 __MAX(0, p_sys->i_pcr - PCR_OFF) );
1467 }
1468 else if( p_sys->i_pcr == VLC_TICK_INVALID ||
1469 i_minpcr > p_sys->i_pcr + PCR_OBS )
1470 {
1471 p_sys->i_pcr = __MAX(0, i_minpcr - PCR_OFF);
1472 if( p_sys->i_pcr != VLC_TICK_INVALID )
1473 es_out_SetPCR( p_demux->out, VLC_TICK_0 + p_sys->i_pcr );
1474 }
1475 }
1476
1477 if( p_sys->b_multicast && p_sys->b_no_data &&
1478 ( p_sys->i_no_data_ti > 120 ) )
1479 {
1480 /* FIXME Make this configurable
1481 msg_Err( p_demux, "no multicast data received in 36s, aborting" );
1482 return 0;
1483 */
1484 }
1485 else if( !p_sys->b_multicast && !p_sys->b_paused &&
1486 p_sys->b_no_data && ( p_sys->i_no_data_ti > 34 ) )
1487 {
1488 bool b_rtsp_tcp = var_GetBool( p_demux, "rtsp-tcp" ) ||
1489 var_GetBool( p_demux, "rtsp-http" );
1490
1491 if( !b_rtsp_tcp && p_sys->rtsp && p_sys->ms )
1492 {
1493 msg_Warn( p_demux, "no data received in 10s. Switching to TCP" );
1494 if( RollOverTcp( p_demux ) )
1495 {
1496 msg_Err( p_demux, "TCP rollover failed, aborting" );
1497 return 0;
1498 }
1499 return 1;
1500 }
1501 msg_Err( p_demux, "no data received in 10s, aborting" );
1502 return 0;
1503 }
1504 else if( !p_sys->b_multicast && !p_sys->b_paused &&
1505 ( p_sys->i_no_data_ti > 34 ) )
1506 {
1507 /* EOF ? */
1508 msg_Warn( p_demux, "no data received in 10s, eof ?" );
1509 return 0;
1510 }
1511 return p_sys->b_error ? 0 : 1;
1512 }
1513
1514 /*****************************************************************************
1515 * Control:
1516 *****************************************************************************/
1517 static int Control( demux_t *p_demux, int i_query, va_list args )
1518 {
1519 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
1520 double *pf, f;
1521 bool *pb;
1522
1523 vlc::threads::mutex_locker locker( p_sys->timeout_mutex ); /* (see same in Demux) */
1524
1525 switch( i_query )
1526 {
1527 case DEMUX_GET_TIME:
1528 if( p_sys->f_npt > 0 )
1529 {
1530 *va_arg( args, vlc_tick_t * ) = vlc_tick_from_sec(p_sys->f_npt);
1531 return VLC_SUCCESS;
1532 }
1533 return VLC_EGENERIC;
1534
1535 case DEMUX_GET_LENGTH:
1536 if( p_sys->f_npt_length > 0 )
1537 {
1538 if( unlikely(p_sys->f_npt_length >= (double)(INT64_MAX / CLOCK_FREQ)) )
1539 *va_arg( args, vlc_tick_t * ) = INT64_MAX;
1540 else
1541 *va_arg( args, vlc_tick_t * ) = vlc_tick_from_sec(p_sys->f_npt_length);
1542 return VLC_SUCCESS;
1543 }
1544 return VLC_EGENERIC;
1545
1546 case DEMUX_GET_POSITION:
1547 pf = va_arg( args, double * );
1548 if( (p_sys->f_npt_length > 0) && (p_sys->f_npt > 0) )
1549 {
1550 *pf = p_sys->f_npt / p_sys->f_npt_length;
1551 return VLC_SUCCESS;
1552 }
1553 return VLC_EGENERIC;
1554
1555 case DEMUX_SET_POSITION:
1556 case DEMUX_SET_TIME:
1557 if( p_sys->rtsp && (p_sys->f_npt_length > 0) )
1558 {
1559 float time;
1560
1561 if( (i_query == DEMUX_SET_TIME) && (p_sys->f_npt > 0) )
1562 {
1563 time = secf_from_vlc_tick(va_arg( args, vlc_tick_t )); /* in second */
1564 }
1565 else if( i_query == DEMUX_SET_TIME )
1566 return VLC_EGENERIC;
1567 else
1568 {
1569 f = va_arg( args, double );
1570 time = f * p_sys->f_npt_length; /* in second */
1571 }
1572
1573 if( p_sys->b_paused )
1574 {
1575 p_sys->f_seek_request = time;
1576 return VLC_SUCCESS;
1577 }
1578
1579 p_sys->rtsp->sendPauseCommand( *p_sys->ms, default_live555_callback );
1580
1581 if( !wait_Live555_response( p_demux ) )
1582 {
1583 msg_Err( p_demux, "PAUSE before seek failed %s",
1584 p_sys->env->getResultMsg() );
1585 return VLC_EGENERIC;
1586 }
1587
1588 p_sys->rtsp->sendPlayCommand( *p_sys->ms, default_live555_callback, time, -1, 1 );
1589
1590 if( !wait_Live555_response( p_demux ) )
1591 {
1592 msg_Err( p_demux, "seek PLAY failed %s",
1593 p_sys->env->getResultMsg() );
1594 return VLC_EGENERIC;
1595 }
1596 p_sys->i_pcr = VLC_TICK_INVALID;
1597
1598 for( int i = 0; i < p_sys->i_track; i++ )
1599 {
1600 p_sys->track[i]->b_rtcp_sync = false;
1601 p_sys->track[i]->i_prevpts = VLC_TICK_INVALID;
1602 p_sys->track[i]->i_pcr = VLC_TICK_INVALID;
1603 dtsgen_Resync( &p_sys->track[i]->dtsgen );
1604 }
1605
1606 /* Retrieve the starttime if possible */
1607 p_sys->f_npt = p_sys->f_npt_start = p_sys->ms->playStartTime();
1608
1609 /* Retrieve the duration if possible */
1610 if( p_sys->ms->playEndTime() > 0 )
1611 p_sys->f_npt_length = p_sys->ms->playEndTime();
1612
1613 msg_Dbg( p_demux, "seek start: %f stop:%f", p_sys->f_npt_start, p_sys->f_npt_length );
1614 return VLC_SUCCESS;
1615 }
1616 return VLC_EGENERIC;
1617
1618 /* Special for access_demux */
1619 case DEMUX_CAN_PAUSE:
1620 case DEMUX_CAN_SEEK:
1621 pb = va_arg( args, bool * );
1622 if( p_sys->rtsp && p_sys->f_npt_length > 0 )
1623 /* Not always true, but will be handled in SET_PAUSE_STATE */
1624 *pb = true;
1625 else
1626 *pb = false;
1627 return VLC_SUCCESS;
1628
1629 case DEMUX_CAN_CONTROL_PACE:
1630 pb = va_arg( args, bool * );
1631
1632 #if 1 /* Disable for now until we have a clock synchro algo
1633 * which works with something else than MPEG over UDP */
1634 *pb = false;
1635 #else
1636 *pb = true;
1637 #endif
1638 return VLC_SUCCESS;
1639
1640 case DEMUX_CAN_CONTROL_RATE:
1641 pb = va_arg( args, bool * );
1642
1643 *pb = (p_sys->rtsp != NULL) &&
1644 (p_sys->f_npt_length > 0) &&
1645 (p_sys->capabilities & CAP_RATE_CONTROL);
1646 return VLC_SUCCESS;
1647
1648 case DEMUX_SET_RATE:
1649 {
1650 float *pf_scale, f_scale;
1651 double f_old_scale;
1652
1653 if( !p_sys->rtsp || (p_sys->f_npt_length <= 0) ||
1654 !(p_sys->capabilities & CAP_RATE_CONTROL) )
1655 return VLC_EGENERIC;
1656
1657 /* According to RFC 2326 p56 chapter 12.35 a RTSP server that
1658 * supports Scale:
1659 *
1660 * "[...] should try to approximate the viewing rate, but
1661 * may restrict the range of scale values that it supports.
1662 * The response MUST contain the actual scale value chosen
1663 * by the server."
1664 *
1665 * Scale = 1 indicates normal play
1666 * Scale > 1 indicates fast forward
1667 * Scale < 1 && Scale > 0 indicates slow motion
1668 * Scale < 0 value indicates rewind
1669 */
1670
1671 pf_scale = va_arg( args, float * );
1672 f_scale = *pf_scale;
1673 f_old_scale = p_sys->ms->scale();
1674
1675 /* Passing -1 for the start and end time will mean liveMedia won't
1676 * create a Range: section for the RTSP message. The server should
1677 * pick up from the current position */
1678 p_sys->rtsp->sendPlayCommand( *p_sys->ms, default_live555_callback, -1, -1, f_scale );
1679
1680 if( !wait_Live555_response( p_demux ) )
1681 {
1682 msg_Err( p_demux, "PLAY with Scale %0.2f failed %s", f_scale,
1683 p_sys->env->getResultMsg() );
1684 return VLC_EGENERIC;
1685 }
1686
1687 if( p_sys->ms->scale() == f_old_scale )
1688 {
1689 msg_Err( p_demux, "no scale change using old Scale %0.2f",
1690 p_sys->ms->scale() );
1691 return VLC_EGENERIC;
1692 }
1693
1694 /* ReSync the stream */
1695 p_sys->f_npt_start = 0;
1696 p_sys->i_pcr = VLC_TICK_INVALID;
1697 p_sys->f_npt = 0.0;
1698
1699 *pf_scale = p_sys->ms->scale() ;
1700 msg_Dbg( p_demux, "PLAY with new Scale %0.2f", p_sys->ms->scale() );
1701 return VLC_SUCCESS;
1702 }
1703
1704 case DEMUX_SET_PAUSE_STATE:
1705 {
1706 bool b_pause = (bool)va_arg( args, int );
1707 if( p_sys->rtsp == NULL )
1708 return VLC_EGENERIC;
1709
1710 if( b_pause == p_sys->b_paused )
1711 return VLC_SUCCESS;
1712 if( b_pause )
1713 p_sys->rtsp->sendPauseCommand( *p_sys->ms, default_live555_callback );
1714 else
1715 p_sys->rtsp->sendPlayCommand( *p_sys->ms, default_live555_callback, p_sys->f_seek_request,
1716 -1.0f, p_sys->ms->scale() );
1717
1718 if( !wait_Live555_response( p_demux ) )
1719 {
1720 msg_Err( p_demux, "PLAY or PAUSE failed %s", p_sys->env->getResultMsg() );
1721 return VLC_EGENERIC;
1722 }
1723 p_sys->f_seek_request = -1;
1724 p_sys->b_paused = b_pause;
1725
1726 if( !p_sys->b_paused )
1727 {
1728 for( int i = 0; i < p_sys->i_track; i++ )
1729 {
1730 live_track_t *tk = p_sys->track[i];
1731 tk->b_rtcp_sync = false;
1732 tk->b_flushing_discontinuity = false;
1733 tk->i_next_block_flags |= BLOCK_FLAG_DISCONTINUITY;
1734 tk->i_prevpts = VLC_TICK_INVALID;
1735 tk->i_pcr = VLC_TICK_INVALID;
1736 }
1737 p_sys->i_pcr = VLC_TICK_INVALID;
1738 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
1739 }
1740
1741 /* Reset data received counter */
1742 p_sys->i_no_data_ti = 0;
1743
1744 /* Retrieve the starttime if possible */
1745 p_sys->f_npt_start = p_sys->ms->playStartTime();
1746
1747 /* Retrieve the duration if possible */
1748 if( p_sys->ms->playEndTime() )
1749 p_sys->f_npt_length = p_sys->ms->playEndTime();
1750
1751 msg_Dbg( p_demux, "pause start: %f stop:%f", p_sys->f_npt_start, p_sys->f_npt_length );
1752
1753 return VLC_SUCCESS;
1754 }
1755 case DEMUX_GET_TITLE_INFO:
1756 case DEMUX_SET_TITLE:
1757 case DEMUX_SET_SEEKPOINT:
1758 return VLC_EGENERIC;
1759
1760 case DEMUX_GET_PTS_DELAY:
1761 *va_arg( args, vlc_tick_t * ) =
1762 VLC_TICK_FROM_MS(var_InheritInteger( p_demux, "network-caching" ));
1763 return VLC_SUCCESS;
1764
1765 default:
1766 return VLC_EGENERIC;
1767 }
1768 }
1769
1770 /*****************************************************************************
1771 * RollOverTcp: reopen the rtsp into TCP mode
1772 * XXX: ugly, a lot of code are duplicated from Open()
1773 * This should REALLY be fixed
1774 *****************************************************************************/
1775 static int RollOverTcp( demux_t *p_demux )
1776 {
1777 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
1778 int i, i_return;
1779
1780 var_SetBool( p_demux, "rtsp-tcp", true );
1781
1782 /* We close the old RTSP session */
1783 vlc_timer_disarm(p_sys->timer);
1784 p_sys->rtsp->sendTeardownCommand( *p_sys->ms, NULL );
1785 Medium::close( p_sys->ms );
1786 RTSPClient::close( p_sys->rtsp );
1787
1788 for( i = 0; i < p_sys->i_track; i++ )
1789 {
1790 live_track_t *tk = p_sys->track[i];
1791
1792 if( tk->p_out_muxed ) vlc_demux_chained_Delete( tk->p_out_muxed );
1793 if( tk->p_es ) es_out_Del( p_demux->out, tk->p_es );
1794 if( tk->p_asf_block ) block_Release( tk->p_asf_block );
1795 es_format_Clean( &tk->fmt );
1796 free( tk->p_buffer );
1797 free( tk );
1798 }
1799 TAB_CLEAN( p_sys->i_track, p_sys->track );
1800 if( p_sys->p_out_asf ) vlc_demux_chained_Delete( p_sys->p_out_asf );
1801
1802 p_sys->ms = NULL;
1803 p_sys->rtsp = NULL;
1804 p_sys->b_no_data = true;
1805 p_sys->i_no_data_ti = 0;
1806 p_sys->p_out_asf = NULL;
1807
1808 /* Reopen rtsp client */
1809 if( ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
1810 {
1811 msg_Err( p_demux, "Failed to connect with %s", p_sys->psz_pl_url );
1812 goto error;
1813 }
1814
1815 if( p_sys->p_sdp == NULL )
1816 {
1817 msg_Err( p_demux, "Failed to retrieve the RTSP Session Description" );
1818 goto error;
1819 }
1820
1821 if( ( i_return = SessionsSetup( p_demux ) ) != VLC_SUCCESS )
1822 {
1823 msg_Err( p_demux, "Nothing to play for %s", p_sys->psz_pl_url );
1824 goto error;
1825 }
1826
1827 if( ( i_return = Play( p_demux ) ) != VLC_SUCCESS )
1828 goto error;
1829
1830 return VLC_SUCCESS;
1831
1832 error:
1833 return VLC_EGENERIC;
1834 }
1835
1836
1837 /*****************************************************************************
1838 *
1839 *****************************************************************************/
1840 static block_t *StreamParseAsf( demux_t *p_demux, live_track_t *tk,
1841 bool b_marker,
1842 const uint8_t *p_data, unsigned i_size )
1843 {
1844 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
1845 const unsigned i_packet_size = p_sys->asfh.i_min_data_packet_size;
1846 block_t *p_list = NULL;
1847
1848 while( i_size >= 4 )
1849 {
1850 unsigned i_flags = p_data[0];
1851 unsigned i_length_offset = (p_data[1] << 16) |
1852 (p_data[2] << 8) |
1853 (p_data[3] );
1854 bool b_length = i_flags & 0x40;
1855 bool b_relative_ts = i_flags & 0x20;
1856 bool b_duration = i_flags & 0x10;
1857 bool b_location_id = i_flags & 0x08;
1858
1859 //msg_Dbg( p_demux, "ASF: marker=%d size=%d : %c=%d id=%d",
1860 // b_marker, i_size, b_length ? 'L' : 'O', i_length_offset );
1861 unsigned i_header_size = 4;
1862 if( b_relative_ts )
1863 i_header_size += 4;
1864 if( b_duration )
1865 i_header_size += 4;
1866 if( b_location_id )
1867 i_header_size += 4;
1868
1869 if( i_header_size > i_size )
1870 {
1871 msg_Warn( p_demux, "Invalid header size" );
1872 break;
1873 }
1874
1875 /* XXX
1876 * When b_length is true, the streams I found do not seems to respect
1877 * the documentation.
1878 * From them, I have failed to find which choice between '__MIN()' or
1879 * 'i_length_offset - i_header_size' is the right one.
1880 */
1881 unsigned i_payload;
1882 if( b_length )
1883 i_payload = __MIN( i_length_offset, i_size - i_header_size);
1884 else
1885 i_payload = i_size - i_header_size;
1886
1887 if( !tk->p_asf_block )
1888 {
1889 tk->p_asf_block = block_Alloc( i_packet_size );
1890 if( !tk->p_asf_block )
1891 break;
1892 tk->p_asf_block->i_buffer = 0;
1893 }
1894 unsigned i_offset = b_length ? 0 : i_length_offset;
1895 if( i_offset == tk->p_asf_block->i_buffer && i_offset + i_payload <= i_packet_size )
1896 {
1897 memcpy( &tk->p_asf_block->p_buffer[i_offset], &p_data[i_header_size], i_payload );
1898 tk->p_asf_block->i_buffer += i_payload;
1899 if( b_marker )
1900 {
1901 /* We have a complete packet */
1902 tk->p_asf_block->i_buffer = i_packet_size;
1903 block_ChainAppend( &p_list, tk->p_asf_block );
1904 tk->p_asf_block = NULL;
1905 }
1906 }
1907 else
1908 {
1909 /* Reset on broken stream */
1910 msg_Err( p_demux, "Broken packet detected (%d vs %zu or %d + %d vs %d)",
1911 i_offset, tk->p_asf_block->i_buffer, i_offset, i_payload, i_packet_size);
1912 tk->p_asf_block->i_buffer = 0;
1913 }
1914
1915 /* */
1916 p_data += i_header_size + i_payload;
1917 i_size -= i_header_size + i_payload;
1918 }
1919 return p_list;
1920 }
1921
1922 /*****************************************************************************
1923 *
1924 *****************************************************************************/
1925 static void StreamRead( void *p_private, unsigned int i_size,
1926 unsigned int i_truncated_bytes, struct timeval pts,
1927 unsigned int duration )
1928 {
1929 VLC_UNUSED( duration );
1930
1931 live_track_t *tk = (live_track_t*)p_private;
1932 demux_t *p_demux = tk->p_demux;
1933 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
1934 block_t *p_block;
1935
1936 //msg_Dbg( p_demux, "pts: %d", pts.tv_sec );
1937
1938 vlc_tick_t i_pts = vlc_tick_from_timeval( &pts );
1939
1940 /* XXX Beurk beurk beurk Avoid having negative value XXX */
1941 i_pts &= INT64_C(0x00ffffffffffffff);
1942
1943 /* Retrieve NPT for this pts */
1944 tk->f_npt = tk->sub->getNormalPlayTime(pts);
1945
1946 if( tk->format == live_track_t::QUICKTIME_STREAM && tk->p_es == NULL )
1947 {
1948 QuickTimeGenericRTPSource *qtRTPSource =
1949 (QuickTimeGenericRTPSource*)tk->sub->rtpSource();
1950 QuickTimeGenericRTPSource::QTState &qtState = qtRTPSource->qtState;
1951 uint8_t *sdAtom = (uint8_t*)&qtState.sdAtom[4];
1952
1953 /* Get codec information from the quicktime atoms :
1954 * http://developer.apple.com/quicktime/icefloe/dispatch026.html */
1955 if( tk->fmt.i_cat == VIDEO_ES ) {
1956 if( qtState.sdAtomSize < 16 + 32 )
1957 {
1958 /* invalid */
1959 p_sys->event_data = 0xff;
1960 tk->waiting = 0;
1961 return;
1962 }
1963 tk->fmt.i_codec = VLC_FOURCC(sdAtom[0],sdAtom[1],sdAtom[2],sdAtom[3]);
1964 tk->fmt.video.i_width = (sdAtom[28] << 8) | sdAtom[29];
1965 tk->fmt.video.i_height = (sdAtom[30] << 8) | sdAtom[31];
1966
1967 if( tk->fmt.i_codec == VLC_FOURCC('a', 'v', 'c', '1') )
1968 {
1969 uint8_t *pos = (uint8_t*)qtRTPSource->qtState.sdAtom + 86;
1970 uint8_t *endpos = (uint8_t*)qtRTPSource->qtState.sdAtom
1971 + qtRTPSource->qtState.sdAtomSize;
1972 while (pos+8 < endpos) {
1973 unsigned int atomLength = pos[0]<<24 | pos[1]<<16 | pos[2]<<8 | pos[3];
1974 if( atomLength == 0 || atomLength > (unsigned int)(endpos-pos)) break;
1975 if( memcmp(pos+4, "avcC", 4) == 0 &&
1976 atomLength > 8 &&
1977 atomLength <= INT_MAX )
1978 {
1979 tk->fmt.i_extra = atomLength-8;
1980 tk->fmt.p_extra = xmalloc( tk->fmt.i_extra );
1981 memcpy(tk->fmt.p_extra, pos+8, atomLength-8);
1982 break;
1983 }
1984 pos += atomLength;
1985 }
1986 }
1987 else
1988 {
1989 tk->fmt.i_extra = qtState.sdAtomSize - 16;
1990 tk->fmt.p_extra = xmalloc( tk->fmt.i_extra );
1991 memcpy( tk->fmt.p_extra, &sdAtom[12], tk->fmt.i_extra );
1992 }
1993 }
1994 else {
1995 if( qtState.sdAtomSize < 24 )
1996 {
1997 /* invalid */
1998 p_sys->event_data = 0xff;
1999 tk->waiting = 0;
2000 return;
2001 }
2002 tk->fmt.i_codec = VLC_FOURCC(sdAtom[0],sdAtom[1],sdAtom[2],sdAtom[3]);
2003 tk->fmt.audio.i_bitspersample = (sdAtom[22] << 8) | sdAtom[23];
2004 }
2005 tk->p_es = es_out_Add( p_demux->out, &tk->fmt );
2006 }
2007
2008 #if 0
2009 fprintf( stderr, "StreamRead size=%d pts=%lld\n",
2010 i_size, vlc_tick_from_timeval( &pts) );
2011 #endif
2012
2013 /* grow buffer if it looks like buffer is too small, but don't eat
2014 * up all the memory on strange streams */
2015 if( i_truncated_bytes > 0 )
2016 {
2017 if( tk->i_buffer < 2000000 )
2018 {
2019 void *p_tmp;
2020 msg_Dbg( p_demux, "lost %d bytes", i_truncated_bytes );
2021 msg_Dbg( p_demux, "increasing buffer size to %d", tk->i_buffer * 2 );
2022 p_tmp = realloc( tk->p_buffer, tk->i_buffer * 2 );
2023 if( p_tmp == NULL )
2024 {
2025 msg_Warn( p_demux, "realloc failed" );
2026 }
2027 else
2028 {
2029 tk->p_buffer = (uint8_t*)p_tmp;
2030 tk->i_buffer *= 2;
2031 }
2032 }
2033
2034 if( tk->b_discard_trunc )
2035 {
2036 p_sys->event_data = 0xff;
2037 tk->waiting = 0;
2038 return;
2039 }
2040 }
2041
2042 assert( i_size <= tk->i_buffer );
2043
2044 if( tk->fmt.i_codec == VLC_CODEC_AMR_NB ||
2045 tk->fmt.i_codec == VLC_CODEC_AMR_WB )
2046 {
2047 AMRAudioSource *amrSource = (AMRAudioSource*)tk->sub->readSource();
2048
2049 if( (p_block = block_Alloc( i_size + 1 )) )
2050 {
2051 p_block->p_buffer[0] = amrSource->lastFrameHeader();
2052 memcpy( p_block->p_buffer + 1, tk->p_buffer, i_size );
2053 }
2054 }
2055 else if( tk->fmt.i_codec == VLC_CODEC_H261 )
2056 {
2057 H261VideoRTPSource *h261Source = (H261VideoRTPSource*)tk->sub->rtpSource();
2058 uint32_t header = h261Source->lastSpecialHeader();
2059 if( (p_block = block_Alloc( i_size + 4 )) )
2060 {
2061 memcpy( p_block->p_buffer, &header, 4 );
2062 memcpy( p_block->p_buffer + 4, tk->p_buffer, i_size );
2063 }
2064 }
2065 else if( tk->fmt.i_codec == VLC_CODEC_H264 || tk->fmt.i_codec == VLC_CODEC_HEVC )
2066 {
2067 if( tk->fmt.i_codec == VLC_CODEC_H264 && (tk->p_buffer[0] & 0x1f) >= 24 )
2068 msg_Warn( p_demux, "unsupported NAL type for H264" );
2069 else if( tk->fmt.i_codec == VLC_CODEC_HEVC && ((tk->p_buffer[0] & 0x7e)>>1) >= 48 )
2070 msg_Warn( p_demux, "unsupported NAL type for H265" );
2071
2072 /* Normal NAL type */
2073 if( (p_block = block_Alloc( i_size + 4 )) )
2074 {
2075 p_block->p_buffer[0] = 0x00;
2076 p_block->p_buffer[1] = 0x00;
2077 p_block->p_buffer[2] = 0x00;
2078 p_block->p_buffer[3] = 0x01;
2079 memcpy( &p_block->p_buffer[4], tk->p_buffer, i_size );
2080 }
2081 }
2082 else if( tk->format == live_track_t::ASF_STREAM )
2083 {
2084 p_block = StreamParseAsf( p_demux, tk,
2085 tk->sub->rtpSource()->curPacketMarkerBit(),
2086 tk->p_buffer, i_size );
2087 }
2088 else
2089 {
2090 if( (p_block = block_Alloc( i_size )) )
2091 memcpy( p_block->p_buffer, tk->p_buffer, i_size );
2092 }
2093
2094 /* No data sent. Always in sync then */
2095 if( !tk->b_rtcp_sync && tk->sub->rtpSource() &&
2096 tk->sub->rtpSource()->hasBeenSynchronizedUsingRTCP() )
2097 {
2098 msg_Dbg( p_demux, "tk->rtpSource->hasBeenSynchronizedUsingRTCP()" );
2099 p_sys->b_rtcp_sync = tk->b_rtcp_sync = true;
2100 if( tk->i_pcr != VLC_TICK_INVALID )
2101 {
2102 tk->i_next_block_flags |= BLOCK_FLAG_DISCONTINUITY;
2103 const vlc_tick_t i_max_diff = vlc_tick_from_sec(( tk->fmt.i_cat == SPU_ES ) ? 60 : 1);
2104 tk->b_flushing_discontinuity = (llabs(i_pts - tk->i_pcr) > i_max_diff);
2105 tk->i_pcr = i_pts;
2106 tk->dtsgen.count = 0;
2107 }
2108 }
2109
2110 /* Update our global npt value */
2111 if( tk->f_npt > 0 &&
2112 ( tk->f_npt < p_sys->f_npt_length || p_sys->f_npt_length <= 0 ) )
2113 p_sys->f_npt = tk->f_npt;
2114
2115 if( p_block )
2116 {
2117 switch( tk->format )
2118 {
2119 case live_track_t::ASF_STREAM:
2120 vlc_demux_chained_Send( p_sys->p_out_asf, p_block );
2121 break;
2122 case live_track_t::MULTIPLEXED_STREAM:
2123 vlc_demux_chained_Send( tk->p_out_muxed, p_block );
2124 break;
2125 default:
2126 if( i_pts != tk->i_prevpts )
2127 {
2128 p_block->i_pts = VLC_TICK_0 + i_pts;
2129 tk->i_prevpts = i_pts;
2130
2131 dtsgen_AddNextPTS( &tk->dtsgen, i_pts );
2132 }
2133
2134 /*FIXME: for h264 you should check that packetization-mode=1 in sdp-file */
2135 switch( tk->fmt.i_codec )
2136 {
2137 case VLC_CODEC_MPGV:
2138 case VLC_CODEC_H264:
2139 case VLC_CODEC_HEVC:
2140 p_block->i_dts = dtsgen_GetDTS( &tk->dtsgen );
2141 dtsgen_Debug( VLC_OBJECT(p_demux), &tk->dtsgen, p_block->i_dts, p_block->i_pts );
2142 break;
2143 case VLC_CODEC_VP8:
2144 default:
2145 p_block->i_dts = VLC_TICK_0 + i_pts;
2146 break;
2147 }
2148
2149 if( i_truncated_bytes )
2150 p_block->i_flags |= BLOCK_FLAG_CORRUPTED;
2151
2152 if( unlikely(tk->i_next_block_flags) )
2153 {
2154 p_block->i_flags |= tk->i_next_block_flags;
2155 tk->i_next_block_flags = 0;
2156 }
2157
2158 vlc_tick_t i_pcr = p_block->i_dts > VLC_TICK_INVALID ? p_block->i_dts : p_block->i_pts;
2159 es_out_Send( p_demux->out, tk->p_es, p_block );
2160 if( i_pcr > VLC_TICK_INVALID )
2161 {
2162 if( tk->i_pcr < i_pcr )
2163 tk->i_pcr = i_pcr;
2164 }
2165 break;
2166 }
2167 }
2168
2169 /* warn that's ok */
2170 p_sys->event_data = 0xff;
2171
2172 /* we have read data */
2173 tk->waiting = 0;
2174 p_sys->b_no_data = false;
2175 p_sys->i_no_data_ti = 0;
2176 }
2177
2178 /*****************************************************************************
2179 *
2180 *****************************************************************************/
2181 static void StreamClose( void *p_private )
2182 {
2183 live_track_t *tk = (live_track_t*)p_private;
2184 demux_t *p_demux = tk->p_demux;
2185 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
2186 tk->state = live_track_t::STATE_IGNORED;
2187 p_sys->event_rtsp = 0xff;
2188 p_sys->event_data = 0xff;
2189
2190 if( tk->p_es )
2191 es_out_Control( p_demux->out, ES_OUT_SET_ES_STATE, tk->p_es, false );
2192
2193 int nb_tracks = 0;
2194 for( int i = 0; i < p_sys->i_track; i++ )
2195 {
2196 if( p_sys->track[i]->state == live_track_t::STATE_SELECTED )
2197 nb_tracks++;
2198 }
2199 msg_Dbg( p_demux, "RTSP track Close, %d track remaining", nb_tracks );
2200 if( !nb_tracks )
2201 p_sys->b_error = true;
2202 }
2203
2204
2205 /*****************************************************************************
2206 *
2207 *****************************************************************************/
2208 static void TaskInterruptRTSP( void *p_private )
2209 {
2210 demux_t *p_demux = (demux_t*)p_private;
2211 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
2212
2213 /* Avoid lock */
2214 p_sys->event_rtsp = 0xff;
2215 }
2216
2217 static void TaskInterruptData( void *p_private )
2218 {
2219 demux_t *p_demux = (demux_t*)p_private;
2220 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
2221
2222 p_sys->i_no_data_ti++;
2223
2224 /* Avoid lock */
2225 p_sys->event_data = 0xff;
2226 }
2227
2228 /*****************************************************************************
2229 *
2230 *****************************************************************************/
2231 static void TimeoutPrevention( void *p_data )
2232 {
2233 demux_t *p_demux = (demux_t *) p_data;
2234 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
2235 char *bye = NULL;
2236
2237 if( var_GetBool( p_demux, "rtsp-tcp" ) )
2238 return;
2239
2240 /* Protect Live555 from us calling their functions simultaneously
2241 with Demux() or Control() */
2242 vlc::threads::mutex_locker locker( p_sys->timeout_mutex );
2243
2244 /* If the timer fires while the demuxer owns the lock, and the demuxer
2245 * then torns the session down, the pointers will become NULL. By the time
2246 * this timer callback obtains the callback, either a new session was
2247 * created and the timer is rescheduled, or the pointers are still NULL
2248 * and the timer is descheduled. In the second case, bail out (then wait
2249 * for the timer to be rescheduled or destroyed). In the first case, this
2250 * might send an early refresh - that´s harmless but suboptimal (FIXME). */
2251 if( p_sys->rtsp == NULL || p_sys->ms == NULL )
2252 return;
2253
2254 bool use_get_param = p_sys->b_get_param;
2255
2256 /* Use GET_PARAMETERS if supported. wmserver dialect supports
2257 * it, but does not report this properly. */
2258 if( var_GetBool( p_demux, "rtsp-wmserver" ) )
2259 use_get_param = true;
2260
2261 if( use_get_param )
2262 p_sys->rtsp->sendGetParameterCommand( *p_sys->ms,
2263 default_live555_callback, bye );
2264 else
2265 p_sys->rtsp->sendOptionsCommand( default_live555_callback, NULL );
2266
2267 if( !wait_Live555_response( p_demux ) )
2268 {
2269 msg_Err( p_demux, "keep-alive failed: %s",
2270 p_sys->env->getResultMsg() );
2271 /* Just continue, worst case is we get timed out later */
2272 }
2273 }
2274
2275 /*****************************************************************************
2276 *
2277 *****************************************************************************/
2278 static int ParseASF( demux_t *p_demux )
2279 {
2280 demux_sys_t *p_sys = (demux_sys_t *)p_demux->p_sys;
2281
2282 const char *psz_marker = "a=pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,";
2283 char *psz_asf = strcasestr( p_sys->p_sdp, psz_marker );
2284 char *psz_end;
2285 block_t *p_header;
2286
2287 /* Parse the asf header */
2288 if( psz_asf == NULL )
2289 return VLC_EGENERIC;
2290
2291 psz_asf += strlen( psz_marker );
2292 psz_asf = strdup( psz_asf ); /* Duplicate it */
2293 psz_end = strchr( psz_asf, '\n' );
2294
2295 while( psz_end > psz_asf && ( *psz_end == '\n' || *psz_end == '\r' ) )
2296 *psz_end-- = '\0';
2297
2298 if( psz_asf >= psz_end )
2299 {
2300 free( psz_asf );
2301 return VLC_EGENERIC;
2302 }
2303
2304 /* Always smaller */
2305 p_header = block_Alloc( psz_end - psz_asf );
2306 p_header->i_buffer = vlc_b64_decode_binary_to_buffer( p_header->p_buffer,
2307 p_header->i_buffer, psz_asf );
2308 //msg_Dbg( p_demux, "Size=%d Hdrb64=%s", p_header->i_buffer, psz_asf );
2309 if( p_header->i_buffer <= 0 )
2310 {
2311 free( psz_asf );
2312 return VLC_EGENERIC;
2313 }
2314
2315 /* Parse it to get packet size */
2316 asf_HeaderParse( &p_sys->asfh, p_header->p_buffer, p_header->i_buffer );
2317
2318 /* Send it to demuxer */
2319 vlc_demux_chained_Send( p_sys->p_out_asf, p_header );
2320
2321 free( psz_asf );
2322 return VLC_SUCCESS;
2323 }
2324
2325
2326 static unsigned char* parseH264ConfigStr( char const* configStr,
2327 unsigned int& configSize )
2328 {
2329 char *dup, *psz;
2330 size_t i_records = 1;
2331
2332 configSize = 0;
2333
2334 if( configStr == NULL || *configStr == '\0' )
2335 return NULL;
2336
2337 psz = dup = strdup( configStr );
2338
2339 /* Count the number of commas */
2340 for( psz = dup; *psz != '\0'; ++psz )
2341 {
2342 if( *psz == ',')
2343 {
2344 ++i_records;
2345 *psz = '\0';
2346 }
2347 }
2348
2349 size_t configMax = 5*strlen(dup);
2350 unsigned char *cfg = new unsigned char[configMax];
2351 psz = dup;
2352 for( size_t i = 0; i < i_records; ++i )
2353 {
2354 cfg[configSize++] = 0x00;
2355 cfg[configSize++] = 0x00;
2356 cfg[configSize++] = 0x00;
2357 cfg[configSize++] = 0x01;
2358
2359 configSize += vlc_b64_decode_binary_to_buffer( cfg+configSize,
2360 configMax-configSize, psz );
2361 psz += strlen(psz)+1;
2362 }
2363
2364 free( dup );
2365 return cfg;
2366 }
2367
2368 static uint8_t *parseVorbisConfigStr( char const* configStr,
2369 unsigned int& configSize )
2370 {
2371 configSize = 0;
2372 if( configStr == NULL || *configStr == '\0' )
2373 return NULL;
2374 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1332115200 // 2012.03.20
2375 unsigned char *p_cfg = base64Decode( configStr, configSize );
2376 #else
2377 char* configStr_dup = strdup( configStr );
2378 unsigned char *p_cfg = base64Decode( configStr_dup, configSize );
2379 free( configStr_dup );
2380 #endif
2381 uint8_t *p_extra = NULL;
2382 /* skip header count, ident number and length (cf. RFC 5215) */
2383 const unsigned int headerSkip = 9;
2384 if( configSize > headerSkip && ((uint8_t*)p_cfg)[3] == 1 )
2385 {
2386 configSize -= headerSkip;
2387 p_extra = (uint8_t*)xmalloc( configSize );
2388 memcpy( p_extra, p_cfg+headerSkip, configSize );
2389 }
2390 delete[] p_cfg;
2391 return p_extra;
2392 }
2393
2394 static char *passwordLessURL( vlc_url_t *p_url )
2395 {
2396 vlc_url_t url;
2397
2398 memcpy( &url, p_url, sizeof( vlc_url_t ) );
2399
2400 url.psz_username = NULL;
2401 url.psz_password = NULL;
2402 if( url.i_port == 0 )
2403 url.i_port = 554;
2404 return vlc_uri_compose( &url );
2405 }
VLC Development tree mirror