modules/stream_out/vod.c

   1 /*****************************************************************************
   2  * vod.c: rtsp VoD server module
   3  *****************************************************************************
   4  * Copyright (C) 2003-2006, 2010 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *          Pierre Ynard
  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 <vlc_common.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_input.h>
  37 #include <vlc_sout.h>
  38 #include <vlc_block.h>
  39
  40 #include <vlc_vod.h>
  41 #include <vlc_url.h>
  42 #include <vlc_network.h>
  43
  44 #include <assert.h>
  45
  46 #include "rtp.h"
  47
  48 /*****************************************************************************
  49  * Exported prototypes
  50  *****************************************************************************/
  51
  52 typedef struct media_es_t media_es_t;
  53
  54 struct media_es_t
  55 {
  56     int es_id;
  57     rtp_format_t rtp_fmt;
  58     rtsp_stream_id_t *rtsp_id;
  59 };
  60
  61 struct vod_media_t
  62 {
  63     /* VoD server */
  64     vod_t *p_vod;
  65
  66     /* RTSP server */
  67     rtsp_stream_t *rtsp;
  68
  69     /* ES list */
  70     int        i_es;
  71     media_es_t **es;
  72     const char *psz_mux;
  73
  74     /* Infos */
  75     mtime_t i_length;
  76 };
  77
  78 struct vod_sys_t
  79 {
  80     char *psz_rtsp_path;
  81
  82     /* */
  83     vlc_thread_t thread;
  84     block_fifo_t *p_fifo_cmd;
  85 };
  86
  87 /* rtsp delayed command (to avoid deadlock between vlm/httpd) */
  88 typedef enum
  89 {
  90     RTSP_CMD_TYPE_STOP,
  91     RTSP_CMD_TYPE_ADD,
  92     RTSP_CMD_TYPE_DEL,
  93 } rtsp_cmd_type_t;
  94
  95 /* */
  96 typedef struct
  97 {
  98     int i_type;
  99     vod_media_t *p_media;
 100     char *psz_arg;
 101 } rtsp_cmd_t;
 102
 103 static vod_media_t *MediaNew( vod_t *, const char *, input_item_t * );
 104 static void         MediaDel( vod_t *, vod_media_t * );
 105 static void         MediaAskDel ( vod_t *, vod_media_t * );
 106
 107 static void* CommandThread( void *obj );
 108 static void  CommandPush( vod_t *, rtsp_cmd_type_t, vod_media_t *,
 109                           const char *psz_arg );
 110
 111 /*****************************************************************************
 112  * Open: Starts the RTSP server module
 113  *****************************************************************************/
 114 int OpenVoD( vlc_object_t *p_this )
 115 {
 116     vod_t *p_vod = (vod_t *)p_this;
 117     vod_sys_t *p_sys = NULL;
 118     char *psz_url;
 119
 120     p_vod->p_sys = p_sys = malloc( sizeof( vod_sys_t ) );
 121     if( !p_sys ) goto error;
 122
 123     psz_url = var_InheritString( p_vod, "rtsp-host" );
 124
 125     if( psz_url == NULL )
 126         p_sys->psz_rtsp_path = strdup( "/" );
 127     else
 128     {
 129         vlc_url_t url;
 130         vlc_UrlParse( &url, psz_url, 0 );
 131         free( psz_url );
 132
 133         if( url.psz_path == NULL )
 134             p_sys->psz_rtsp_path = strdup( "/" );
 135         else
 136         if( !( strlen( url.psz_path ) > 0
 137                && url.psz_path[strlen( url.psz_path ) - 1] == '/' ) )
 138         {
 139             if( asprintf( &p_sys->psz_rtsp_path, "%s/", url.psz_path ) == -1 )
 140             {
 141                 p_sys->psz_rtsp_path = NULL;
 142                 vlc_UrlClean( &url );
 143                 goto error;
 144             }
 145         }
 146         else
 147             p_sys->psz_rtsp_path = strdup( url.psz_path );
 148
 149         vlc_UrlClean( &url );
 150     }
 151
 152     p_vod->pf_media_new = MediaNew;
 153     p_vod->pf_media_del = MediaAskDel;
 154
 155     p_sys->p_fifo_cmd = block_FifoNew();
 156     if( vlc_clone( &p_sys->thread, CommandThread, p_vod, VLC_THREAD_PRIORITY_LOW ) )
 157     {
 158         msg_Err( p_vod, "cannot spawn rtsp vod thread" );
 159         block_FifoRelease( p_sys->p_fifo_cmd );
 160         goto error;
 161     }
 162
 163     return VLC_SUCCESS;
 164
 165 error:
 166     if( p_sys )
 167     {
 168         free( p_sys->psz_rtsp_path );
 169         free( p_sys );
 170     }
 171
 172     return VLC_EGENERIC;
 173 }
 174
 175 /*****************************************************************************
 176  * Close:
 177  *****************************************************************************/
 178 void CloseVoD( vlc_object_t * p_this )
 179 {
 180     vod_t *p_vod = (vod_t *)p_this;
 181     vod_sys_t *p_sys = p_vod->p_sys;
 182
 183     /* Stop command thread */
 184     vlc_cancel( p_sys->thread );
 185     vlc_join( p_sys->thread, NULL );
 186
 187     while( block_FifoCount( p_sys->p_fifo_cmd ) > 0 )
 188     {
 189         rtsp_cmd_t cmd;
 190         block_t *p_block_cmd = block_FifoGet( p_sys->p_fifo_cmd );
 191         memcpy( &cmd, p_block_cmd->p_buffer, sizeof(cmd) );
 192         block_Release( p_block_cmd );
 193         if ( cmd.i_type == RTSP_CMD_TYPE_DEL )
 194             MediaDel(p_vod, cmd.p_media);
 195         free( cmd.psz_arg );
 196     }
 197     block_FifoRelease( p_sys->p_fifo_cmd );
 198
 199     free( p_sys->psz_rtsp_path );
 200     free( p_sys );
 201 }
 202
 203 /*****************************************************************************
 204  * Media handling
 205  *****************************************************************************/
 206 static vod_media_t *MediaNew( vod_t *p_vod, const char *psz_name,
 207                               input_item_t *p_item )
 208 {
 209     vod_media_t *p_media = calloc( 1, sizeof(vod_media_t) );
 210     if( !p_media )
 211         return NULL;
 212
 213     p_media->p_vod = p_vod;
 214     p_media->rtsp = NULL;
 215     TAB_INIT( p_media->i_es, p_media->es );
 216     p_media->psz_mux = NULL;
 217     p_media->i_length = input_item_GetDuration( p_item );
 218
 219     vlc_mutex_lock( &p_item->lock );
 220     msg_Dbg( p_vod, "media '%s' has %i declared ES", psz_name, p_item->i_es );
 221     for( int i = 0; i < p_item->i_es; i++ )
 222     {
 223         es_format_t *p_fmt = p_item->es[i];
 224
 225         switch( p_fmt->i_codec )
 226         {
 227             case VLC_FOURCC( 'm', 'p', '2', 't' ):
 228                 p_media->psz_mux = "ts";
 229                 break;
 230             case VLC_FOURCC( 'm', 'p', '2', 'p' ):
 231                 p_media->psz_mux = "ps";
 232                 break;
 233         }
 234         assert(p_media->psz_mux == NULL || p_item->i_es == 1);
 235
 236         media_es_t *p_es = calloc( 1, sizeof(media_es_t) );
 237         if( !p_es )
 238             continue;
 239
 240         p_es->es_id = p_fmt->i_id;
 241         p_es->rtsp_id = NULL;
 242
 243         if (rtp_get_fmt(VLC_OBJECT(p_vod), p_fmt, p_media->psz_mux,
 244                         &p_es->rtp_fmt) != VLC_SUCCESS)
 245         {
 246             free(p_es);
 247             continue;
 248         }
 249
 250         TAB_APPEND( p_media->i_es, p_media->es, p_es );
 251         msg_Dbg(p_vod, "  - added ES %u %s (%4.4s)",
 252                 p_es->rtp_fmt.payload_type, p_es->rtp_fmt.ptname,
 253                 (char *)&p_fmt->i_codec);
 254     }
 255     vlc_mutex_unlock( &p_item->lock );
 256
 257     if (p_media->i_es == 0)
 258     {
 259         msg_Err(p_vod, "no ES was added to the media, aborting");
 260         goto error;
 261     }
 262
 263     msg_Dbg(p_vod, "adding media '%s'", psz_name);
 264
 265     CommandPush( p_vod, RTSP_CMD_TYPE_ADD, p_media, psz_name );
 266     return p_media;
 267
 268 error:
 269     MediaDel(p_vod, p_media);
 270     return NULL;
 271 }
 272
 273 static void MediaSetup( vod_t *p_vod, vod_media_t *p_media,
 274                         const char *psz_name )
 275 {
 276     vod_sys_t *p_sys = p_vod->p_sys;
 277     char *psz_path;
 278
 279     if( asprintf( &psz_path, "%s%s", p_sys->psz_rtsp_path, psz_name ) < 0 )
 280         return;
 281
 282     p_media->rtsp = RtspSetup(VLC_OBJECT(p_vod), p_media, psz_path);
 283     free( psz_path );
 284
 285     if (p_media->rtsp == NULL)
 286         return;
 287
 288     for (int i = 0; i < p_media->i_es; i++)
 289     {
 290         media_es_t *p_es = p_media->es[i];
 291         p_es->rtsp_id = RtspAddId(p_media->rtsp, NULL, 0,
 292                                   p_es->rtp_fmt.clock_rate, -1);
 293     }
 294 }
 295
 296 static void MediaAskDel ( vod_t *p_vod, vod_media_t *p_media )
 297 {
 298     msg_Dbg( p_vod, "deleting media" );
 299     CommandPush( p_vod, RTSP_CMD_TYPE_DEL, p_media, NULL );
 300 }
 301
 302 static void MediaDel( vod_t *p_vod, vod_media_t *p_media )
 303 {
 304     (void) p_vod;
 305
 306     if (p_media->rtsp != NULL)
 307     {
 308         for (int i = 0; i < p_media->i_es; i++)
 309         {
 310             media_es_t *p_es = p_media->es[i];
 311             if (p_es->rtsp_id != NULL)
 312                 RtspDelId(p_media->rtsp, p_es->rtsp_id);
 313         }
 314         RtspUnsetup(p_media->rtsp);
 315     }
 316
 317     for( int i = 0; i < p_media->i_es; i++ )
 318     {
 319         free( p_media->es[i]->rtp_fmt.fmtp );
 320         free( p_media->es[i] );
 321     }
 322     free( p_media->es );
 323
 324     free( p_media );
 325 }
 326
 327 static void CommandPush( vod_t *p_vod, rtsp_cmd_type_t i_type,
 328                          vod_media_t *p_media, const char *psz_arg )
 329 {
 330     rtsp_cmd_t cmd;
 331     block_t *p_cmd;
 332
 333     cmd.i_type = i_type;
 334     cmd.p_media = p_media;
 335     if( psz_arg )
 336         cmd.psz_arg = strdup(psz_arg);
 337     else
 338         cmd.psz_arg = NULL;
 339
 340     p_cmd = block_Alloc( sizeof(rtsp_cmd_t) );
 341     memcpy( p_cmd->p_buffer, &cmd, sizeof(cmd) );
 342
 343     block_FifoPut( p_vod->p_sys->p_fifo_cmd, p_cmd );
 344 }
 345
 346 static void* CommandThread( void *obj )
 347 {
 348     vod_t *p_vod = (vod_t*)obj;
 349     vod_sys_t *p_sys = p_vod->p_sys;
 350
 351     for( ;; )
 352     {
 353         block_t *p_block_cmd = block_FifoGet( p_sys->p_fifo_cmd );
 354         rtsp_cmd_t cmd;
 355
 356         if( !p_block_cmd )
 357             break;
 358
 359         int canc = vlc_savecancel ();
 360         memcpy( &cmd, p_block_cmd->p_buffer, sizeof(cmd) );
 361         block_Release( p_block_cmd );
 362
 363         /* */
 364         switch( cmd.i_type )
 365         {
 366         case RTSP_CMD_TYPE_ADD:
 367             MediaSetup(p_vod, cmd.p_media, cmd.psz_arg);
 368             break;
 369         case RTSP_CMD_TYPE_DEL:
 370             MediaDel(p_vod, cmd.p_media);
 371             break;
 372         case RTSP_CMD_TYPE_STOP:
 373             vod_MediaControl( p_vod, cmd.p_media, cmd.psz_arg, VOD_MEDIA_STOP );
 374             break;
 375
 376         default:
 377             break;
 378         }
 379
 380         free( cmd.psz_arg );
 381         vlc_restorecancel (canc);
 382     }
 383
 384     return NULL;
 385 }
 386
 387 /*****************************************************************************
 388  * SDPGenerateVoD
 389  * FIXME: needs to be merged more?
 390  *****************************************************************************/
 391 char *SDPGenerateVoD( const vod_media_t *p_media, const char *rtsp_url )
 392 {
 393     char *psz_sdp;
 394
 395     assert(rtsp_url != NULL);
 396     /* Check against URL format rtsp://[<ipv6>]:<port>/<path> */
 397     bool ipv6 = strlen( rtsp_url ) > 7 && rtsp_url[7] == '[';
 398
 399     /* Dummy destination address for RTSP */
 400     struct sockaddr_storage dst;
 401     socklen_t dstlen = ipv6 ? sizeof( struct sockaddr_in6 )
 402                             : sizeof( struct sockaddr_in );
 403     memset (&dst, 0, dstlen);
 404     dst.ss_family = ipv6 ? AF_INET6 : AF_INET;
 405 #ifdef HAVE_SA_LEN
 406     dst.ss_len = dstlen;
 407 #endif
 408
 409     psz_sdp = vlc_sdp_Start( VLC_OBJECT( p_media->p_vod ), "sout-rtp-",
 410                              NULL, 0, (struct sockaddr *)&dst, dstlen );
 411     if( psz_sdp == NULL )
 412         return NULL;
 413
 414     if( p_media->i_length > 0 )
 415     {
 416         lldiv_t d = lldiv( p_media->i_length / 1000, 1000 );
 417         sdp_AddAttribute( &psz_sdp, "range"," npt=0-%lld.%03u", d.quot,
 418                           (unsigned)d.rem );
 419     }
 420
 421     sdp_AddAttribute ( &psz_sdp, "control", "%s", rtsp_url );
 422
 423     /* No locking needed, the ES table can't be modified now */
 424     for( int i = 0; i < p_media->i_es; i++ )
 425     {
 426         media_es_t *p_es = p_media->es[i];
 427         rtp_format_t *rtp_fmt = &p_es->rtp_fmt;
 428         const char *mime_major; /* major MIME type */
 429
 430         switch( rtp_fmt->cat )
 431         {
 432             case VIDEO_ES:
 433                 mime_major = "video";
 434                 break;
 435             case AUDIO_ES:
 436                 mime_major = "audio";
 437                 break;
 438             case SPU_ES:
 439                 mime_major = "text";
 440                 break;
 441             default:
 442                 continue;
 443         }
 444
 445         sdp_AddMedia( &psz_sdp, mime_major, "RTP/AVP", 0,
 446                       rtp_fmt->payload_type, false, 0,
 447                       rtp_fmt->ptname, rtp_fmt->clock_rate, rtp_fmt->channels,
 448                       rtp_fmt->fmtp );
 449
 450         char *track_url = RtspAppendTrackPath( p_es->rtsp_id, rtsp_url );
 451         if( track_url != NULL )
 452         {
 453             sdp_AddAttribute ( &psz_sdp, "control", "%s", track_url );
 454             free( track_url );
 455         }
 456     }
 457
 458     return psz_sdp;
 459 }
 460
 461 int vod_check_range(vod_media_t *p_media, const char *psz_session,
 462                     int64_t start, int64_t end)
 463 {
 464     (void) psz_session;
 465
 466     if (p_media->i_length > 0 && (start > p_media->i_length
 467                                   || end > p_media->i_length))
 468         return VLC_EGENERIC;
 469
 470     return VLC_SUCCESS;
 471 }
 472
 473 /* TODO: add support in the VLM for queueing proper PLAY requests with
 474  * start and end times, fetch whether the input is seekable... and then
 475  * clean this up */
 476 void vod_play(vod_media_t *p_media, const char *psz_session,
 477               int64_t *start, int64_t end)
 478 {
 479     if (vod_check_range(p_media, psz_session, *start, end) != VLC_SUCCESS)
 480         return;
 481
 482     /* We're passing the #vod{} sout chain here */
 483     vod_MediaControl(p_media->p_vod, p_media, psz_session,
 484                      VOD_MEDIA_PLAY, "vod", start);
 485 }
 486
 487 void vod_pause(vod_media_t *p_media, const char *psz_session, int64_t *npt)
 488 {
 489     vod_MediaControl(p_media->p_vod, p_media, psz_session,
 490                      VOD_MEDIA_PAUSE, npt);
 491 }
 492
 493 void vod_stop(vod_media_t *p_media, const char *psz_session)
 494 {
 495     CommandPush(p_media->p_vod, RTSP_CMD_TYPE_STOP, p_media, psz_session);
 496 }
 497
 498
 499 const char *vod_get_mux(const vod_media_t *p_media)
 500 {
 501     return p_media->psz_mux;
 502 }
 503
 504
 505 /* Match an RTP id to a VoD media ES and RTSP track to initialize it
 506  * with the data that was already set up */
 507 int vod_init_id(vod_media_t *p_media, const char *psz_session, int es_id,
 508                 sout_stream_id_sys_t *sout_id, rtp_format_t *rtp_fmt,
 509                 uint32_t *ssrc, uint16_t *seq_init)
 510 {
 511     media_es_t *p_es;
 512
 513     if (p_media->psz_mux != NULL)
 514     {
 515         assert(p_media->i_es == 1);
 516         p_es = p_media->es[0];
 517     }
 518     else
 519     {
 520         p_es = NULL;
 521         /* No locking needed, the ES table can't be modified now */
 522         for (int i = 0; i < p_media->i_es; i++)
 523         {
 524             if (p_media->es[i]->es_id == es_id)
 525             {
 526                 p_es = p_media->es[i];
 527                 break;
 528             }
 529         }
 530         if (p_es == NULL)
 531             return VLC_EGENERIC;
 532     }
 533
 534     memcpy(rtp_fmt, &p_es->rtp_fmt, sizeof(*rtp_fmt));
 535     if (p_es->rtp_fmt.fmtp != NULL)
 536         rtp_fmt->fmtp = strdup(p_es->rtp_fmt.fmtp);
 537
 538     return RtspTrackAttach(p_media->rtsp, psz_session, p_es->rtsp_id,
 539                            sout_id, ssrc, seq_init);
 540 }
 541
 542 /* Remove references to the RTP id from its RTSP track */
 543 void vod_detach_id(vod_media_t *p_media, const char *psz_session,
 544                    sout_stream_id_sys_t *sout_id)
 545 {
 546     RtspTrackDetach(p_media->rtsp, psz_session, sout_id);
 547 }
 548