开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
rtp.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：57k
源码类别：

midi

开发平台：

Unix_Linux

rtp.c：源码内容
  1. /*****************************************************************************
  2.  * rtp.c: rtp stream output module
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2004 the VideoLAN team
  5.  * Copyright © 2007-2008 Rémi Denis-Courmont
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <vlc_common.h>
  33. #include <vlc_plugin.h>
  34. #include <vlc_sout.h>
  35. #include <vlc_block.h>
  37. #include <vlc_httpd.h>
  38. #include <vlc_url.h>
  39. #include <vlc_network.h>
  40. #include <vlc_charset.h>
  41. #include <vlc_strings.h>
  42. #include <vlc_rand.h>
  43. #include <srtp.h>
  45. #include "rtp.h"
  47. #ifdef HAVE_UNISTD_H
  48. #   include <sys/types.h>
  49. #   include <unistd.h>
  50. #   include <fcntl.h>
  51. #   include <sys/stat.h>
  52. #endif
  53. #ifdef HAVE_LINUX_DCCP_H
  54. #   include <linux/dccp.h>
  55. #endif
  56. #ifndef IPPROTO_DCCP
  57. # define IPPROTO_DCCP 33
  58. #endif
  59. #ifndef IPPROTO_UDPLITE
  60. # define IPPROTO_UDPLITE 136
  61. #endif
  63. #include <errno.h>
  65. #include <assert.h>
  67. /*****************************************************************************
  68.  * Module descriptor
  69.  *****************************************************************************/
  71. #define DEST_TEXT N_("Destination")
  72. #define DEST_LONGTEXT N_( 
  73.     "This is the output URL that will be used." )
  74. #define SDP_TEXT N_("SDP")
  75. #define SDP_LONGTEXT N_( 
  76.     "This allows you to specify how the SDP (Session Descriptor) for this RTP "
  77.     "session will be made available. You must use an url: http://location to " 
  78.     "access the SDP via HTTP, rtsp://location for RTSP access, and sap:// " 
  79.     "for the SDP to be announced via SAP." )
  80. #define SAP_TEXT N_("SAP announcing")
  81. #define SAP_LONGTEXT N_("Announce this session with SAP.")
  82. #define MUX_TEXT N_("Muxer")
  83. #define MUX_LONGTEXT N_( 
  84.     "This allows you to specify the muxer used for the streaming output. " 
  85.     "Default is to use no muxer (standard RTP stream)." )
  87. #define NAME_TEXT N_("Session name")
  88. #define NAME_LONGTEXT N_( 
  89.     "This is the name of the session that will be announced in the SDP " 
  90.     "(Session Descriptor)." )
  91. #define DESC_TEXT N_("Session description")
  92. #define DESC_LONGTEXT N_( 
  93.     "This allows you to give a short description with details about the stream, " 
  94.     "that will be announced in the SDP (Session Descriptor)." )
  95. #define URL_TEXT N_("Session URL")
  96. #define URL_LONGTEXT N_( 
  97.     "This allows you to give an URL with more details about the stream " 
  98.     "(often the website of the streaming organization), that will " 
  99.     "be announced in the SDP (Session Descriptor)." )
  100. #define EMAIL_TEXT N_("Session email")
  101. #define EMAIL_LONGTEXT N_( 
  102.     "This allows you to give a contact mail address for the stream, that will " 
  103.     "be announced in the SDP (Session Descriptor)." )
  104. #define PHONE_TEXT N_("Session phone number")
  105. #define PHONE_LONGTEXT N_( 
  106.     "This allows you to give a contact telephone number for the stream, that will " 
  107.     "be announced in the SDP (Session Descriptor)." )
  109. #define PORT_TEXT N_("Port")
  110. #define PORT_LONGTEXT N_( 
  111.     "This allows you to specify the base port for the RTP streaming." )
  112. #define PORT_AUDIO_TEXT N_("Audio port")
  113. #define PORT_AUDIO_LONGTEXT N_( 
  114.     "This allows you to specify the default audio port for the RTP streaming." )
  115. #define PORT_VIDEO_TEXT N_("Video port")
  116. #define PORT_VIDEO_LONGTEXT N_( 
  117.     "This allows you to specify the default video port for the RTP streaming." )
  119. #define TTL_TEXT N_("Hop limit (TTL)")
  120. #define TTL_LONGTEXT N_( 
  121.     "This is the hop limit (also known as "Time-To-Live" or TTL) of " 
  122.     "the multicast packets sent by the stream output (-1 = use operating " 
  123.     "system built-in default).")
  125. #define RTCP_MUX_TEXT N_("RTP/RTCP multiplexing")
  126. #define RTCP_MUX_LONGTEXT N_( 
  127.     "This sends and receives RTCP packet multiplexed over the same port " 
  128.     "as RTP packets." )
  130. #define PROTO_TEXT N_("Transport protocol")
  131. #define PROTO_LONGTEXT N_( 
  132.     "This selects which transport protocol to use for RTP." )
  134. #define SRTP_KEY_TEXT N_("SRTP key (hexadecimal)")
  135. #define SRTP_KEY_LONGTEXT N_( 
  136.     "RTP packets will be integrity-protected and ciphered "
  137.     "with this Secure RTP master shared secret key.")
  139. #define SRTP_SALT_TEXT N_("SRTP salt (hexadecimal)")
  140. #define SRTP_SALT_LONGTEXT N_( 
  141.     "Secure RTP requires a (non-secret) master salt value.")
  143. static const char *const ppsz_protos[] = {
  144.     "dccp", "sctp", "tcp", "udp", "udplite",
  145. };
  147. static const char *const ppsz_protocols[] = {
  148.     "DCCP", "SCTP", "TCP", "UDP", "UDP-Lite",
  149. };
  151. #define RFC3016_TEXT N_("MP4A LATM")
  152. #define RFC3016_LONGTEXT N_( 
  153.     "This allows you to stream MPEG4 LATM audio streams (see RFC3016)." )
  155. static int  Open ( vlc_object_t * );
  156. static void Close( vlc_object_t * );
  158. #define SOUT_CFG_PREFIX "sout-rtp-"
  159. #define MAX_EMPTY_BLOCKS 200
  161. vlc_module_begin ()
  162.     set_shortname( N_("RTP"))
  163.     set_description( N_("RTP stream output") )
  164.     set_capability( "sout stream", 0 )
  165.     add_shortcut( "rtp" )
  166.     set_category( CAT_SOUT )
  167.     set_subcategory( SUBCAT_SOUT_STREAM )
  169.     add_string( SOUT_CFG_PREFIX "dst", "", NULL, DEST_TEXT,
  170.                 DEST_LONGTEXT, true )
  171.     add_string( SOUT_CFG_PREFIX "sdp", "", NULL, SDP_TEXT,
  172.                 SDP_LONGTEXT, true )
  173.     add_string( SOUT_CFG_PREFIX "mux", "", NULL, MUX_TEXT,
  174.                 MUX_LONGTEXT, true )
  175.     add_bool( SOUT_CFG_PREFIX "sap", false, NULL, SAP_TEXT, SAP_LONGTEXT,
  176.               true )
  178.     add_string( SOUT_CFG_PREFIX "name", "", NULL, NAME_TEXT,
  179.                 NAME_LONGTEXT, true )
  180.     add_string( SOUT_CFG_PREFIX "description", "", NULL, DESC_TEXT,
  181.                 DESC_LONGTEXT, true )
  182.     add_string( SOUT_CFG_PREFIX "url", "", NULL, URL_TEXT,
  183.                 URL_LONGTEXT, true )
  184.     add_string( SOUT_CFG_PREFIX "email", "", NULL, EMAIL_TEXT,
  185.                 EMAIL_LONGTEXT, true )
  186.     add_string( SOUT_CFG_PREFIX "phone", "", NULL, PHONE_TEXT,
  187.                 PHONE_LONGTEXT, true )
  189.     add_string( SOUT_CFG_PREFIX "proto", "udp", NULL, PROTO_TEXT,
  190.                 PROTO_LONGTEXT, false )
  191.         change_string_list( ppsz_protos, ppsz_protocols, NULL )
  192.     add_integer( SOUT_CFG_PREFIX "port", 5004, NULL, PORT_TEXT,
  193.                  PORT_LONGTEXT, true )
  194.     add_integer( SOUT_CFG_PREFIX "port-audio", 0, NULL, PORT_AUDIO_TEXT,
  195.                  PORT_AUDIO_LONGTEXT, true )
  196.     add_integer( SOUT_CFG_PREFIX "port-video", 0, NULL, PORT_VIDEO_TEXT,
  197.                  PORT_VIDEO_LONGTEXT, true )
  199.     add_integer( SOUT_CFG_PREFIX "ttl", -1, NULL, TTL_TEXT,
  200.                  TTL_LONGTEXT, true )
  201.     add_bool( SOUT_CFG_PREFIX "rtcp-mux", false, NULL,
  202.               RTCP_MUX_TEXT, RTCP_MUX_LONGTEXT, false )
  204.     add_string( SOUT_CFG_PREFIX "key", "", NULL,
  205.                 SRTP_KEY_TEXT, SRTP_KEY_LONGTEXT, false )
  206.     add_string( SOUT_CFG_PREFIX "salt", "", NULL,
  207.                 SRTP_SALT_TEXT, SRTP_SALT_LONGTEXT, false )
  209.     add_bool( SOUT_CFG_PREFIX "mp4a-latm", 0, NULL, RFC3016_TEXT,
  210.                  RFC3016_LONGTEXT, false )
  212.     set_callbacks( Open, Close )
  213. vlc_module_end ()
  215. /*****************************************************************************
  216.  * Exported prototypes
  217.  *****************************************************************************/
  218. static const char *const ppsz_sout_options[] = {
  219.     "dst", "name", "port", "port-audio", "port-video", "*sdp", "ttl", "mux",
  220.     "sap", "description", "url", "email", "phone",
  221.     "proto", "rtcp-mux", "key", "salt",
  222.     "mp4a-latm", NULL
  223. };
  225. static sout_stream_id_t *Add ( sout_stream_t *, es_format_t * );
  226. static int               Del ( sout_stream_t *, sout_stream_id_t * );
  227. static int               Send( sout_stream_t *, sout_stream_id_t *,
  228.                                block_t* );
  229. static sout_stream_id_t *MuxAdd ( sout_stream_t *, es_format_t * );
  230. static int               MuxDel ( sout_stream_t *, sout_stream_id_t * );
  231. static int               MuxSend( sout_stream_t *, sout_stream_id_t *,
  232.                                   block_t* );
  234. static sout_access_out_t *GrabberCreate( sout_stream_t *p_sout );
  235. static void* ThreadSend( vlc_object_t *p_this );
  237. static void SDPHandleUrl( sout_stream_t *, const char * );
  239. static int SapSetup( sout_stream_t *p_stream );
  240. static int FileSetup( sout_stream_t *p_stream );
  241. static int HttpSetup( sout_stream_t *p_stream, const vlc_url_t * );
  243. struct sout_stream_sys_t
  244. {
  245.     /* SDP */
  246.     char    *psz_sdp;
  247.     vlc_mutex_t  lock_sdp;
  249.     /* SDP to disk */
  250.     bool b_export_sdp_file;
  251.     char *psz_sdp_file;
  253.     /* SDP via SAP */
  254.     bool b_export_sap;
  255.     session_descriptor_t *p_session;
  257.     /* SDP via HTTP */
  258.     httpd_host_t *p_httpd_host;
  259.     httpd_file_t *p_httpd_file;
  261.     /* RTSP */
  262.     rtsp_stream_t *rtsp;
  264.     /* */
  265.     char     *psz_destination;
  266.     uint32_t  payload_bitmap;
  267.     uint16_t  i_port;
  268.     uint16_t  i_port_audio;
  269.     uint16_t  i_port_video;
  270.     uint8_t   proto;
  271.     bool      rtcp_mux;
  272.     int       i_ttl:9;
  273.     bool      b_latm;
  275.     /* in case we do TS/PS over rtp */
  276.     sout_mux_t        *p_mux;
  277.     sout_access_out_t *p_grab;
  278.     block_t           *packet;
  280.     /* */
  281.     vlc_mutex_t      lock_es;
  282.     int              i_es;
  283.     sout_stream_id_t **es;
  284. };
  286. typedef int (*pf_rtp_packetizer_t)( sout_stream_id_t *, block_t * );
  288. typedef struct rtp_sink_t
  289. {
  290.     int rtp_fd;
  291.     rtcp_sender_t *rtcp;
  292. } rtp_sink_t;
  294. struct sout_stream_id_t
  295. {
  296.     VLC_COMMON_MEMBERS
  298.     sout_stream_t *p_stream;
  299.     /* rtp field */
  300.     uint32_t    i_timestamp;
  301.     uint16_t    i_sequence;
  302.     uint8_t     i_payload_type;
  303.     uint8_t     ssrc[4];
  305.     /* for sdp */
  306.     const char  *psz_enc;
  307.     char        *psz_fmtp;
  308.     int          i_clock_rate;
  309.     int          i_port;
  310.     int          i_cat;
  311.     int          i_channels;
  312.     int          i_bitrate;
  314.     /* Packetizer specific fields */
  315.     int                 i_mtu;
  316.     srtp_session_t     *srtp;
  317.     pf_rtp_packetizer_t pf_packetize;
  319.     /* Packets sinks */
  320.     vlc_mutex_t       lock_sink;
  321.     int               sinkc;
  322.     rtp_sink_t       *sinkv;
  323.     rtsp_stream_id_t *rtsp_id;
  324.     int              *listen_fd;
  326.     block_fifo_t     *p_fifo;
  327.     int64_t           i_caching;
  328. };
  330. /*****************************************************************************
  331.  * Open:
  332.  *****************************************************************************/
  333. static int Open( vlc_object_t *p_this )
  334. {
  335.     sout_stream_t       *p_stream = (sout_stream_t*)p_this;
  336.     sout_instance_t     *p_sout = p_stream->p_sout;
  337.     sout_stream_sys_t   *p_sys = NULL;
  338.     config_chain_t      *p_cfg = NULL;
  339.     char                *psz;
  340.     bool          b_rtsp = false;
  342.     config_ChainParse( p_stream, SOUT_CFG_PREFIX,
  343.                        ppsz_sout_options, p_stream->p_cfg );
  345.     p_sys = malloc( sizeof( sout_stream_sys_t ) );
  346.     if( p_sys == NULL )
  347.         return VLC_ENOMEM;
  349.     p_sys->psz_destination = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "dst" );
  351.     p_sys->i_port       = var_GetInteger( p_stream, SOUT_CFG_PREFIX "port" );
  352.     p_sys->i_port_audio = var_GetInteger( p_stream, SOUT_CFG_PREFIX "port-audio" );
  353.     p_sys->i_port_video = var_GetInteger( p_stream, SOUT_CFG_PREFIX "port-video" );
  354.     p_sys->rtcp_mux     = var_GetBool( p_stream, SOUT_CFG_PREFIX "rtcp-mux" );
  356.     p_sys->psz_sdp_file = NULL;
  358.     if( p_sys->i_port_audio && p_sys->i_port_video == p_sys->i_port_audio )
  359.     {
  360.         msg_Err( p_stream, "audio and video RTP port must be distinct" );
  361.         free( p_sys->psz_destination );
  362.         free( p_sys );
  363.         return VLC_EGENERIC;
  364.     }
  366.     for( p_cfg = p_stream->p_cfg; p_cfg != NULL; p_cfg = p_cfg->p_next )
  367.     {
  368.         if( !strcmp( p_cfg->psz_name, "sdp" )
  369.          && ( p_cfg->psz_value != NULL )
  370.          && !strncasecmp( p_cfg->psz_value, "rtsp:", 5 ) )
  371.         {
  372.             b_rtsp = true;
  373.             break;
  374.         }
  375.     }
  376.     if( !b_rtsp )
  377.     {
  378.         psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "sdp" );
  379.         if( psz != NULL )
  380.         {
  381.             if( !strncasecmp( psz, "rtsp:", 5 ) )
  382.                 b_rtsp = true;
  383.             free( psz );
  384.         }
  385.     }
  387.     /* Transport protocol */
  388.     p_sys->proto = IPPROTO_UDP;
  389.     psz = var_GetNonEmptyString (p_stream, SOUT_CFG_PREFIX"proto");
  391.     if ((psz == NULL) || !strcasecmp (psz, "udp"))
  392.         (void)0; /* default */
  393.     else
  394.     if (!strcasecmp (psz, "dccp"))
  395.     {
  396.         p_sys->proto = IPPROTO_DCCP;
  397.         p_sys->rtcp_mux = true; /* Force RTP/RTCP mux */
  398.     }
  399. #if 0
  400.     else
  401.     if (!strcasecmp (psz, "sctp"))
  402.     {
  403.         p_sys->proto = IPPROTO_TCP;
  404.         p_sys->rtcp_mux = true; /* Force RTP/RTCP mux */
  405.     }
  406. #endif
  407. #if 0
  408.     else
  409.     if (!strcasecmp (psz, "tcp"))
  410.     {
  411.         p_sys->proto = IPPROTO_TCP;
  412.         p_sys->rtcp_mux = true; /* Force RTP/RTCP mux */
  413.     }
  414. #endif
  415.     else
  416.     if (!strcasecmp (psz, "udplite") || !strcasecmp (psz, "udp-lite"))
  417.         p_sys->proto = IPPROTO_UDPLITE;
  418.     else
  419.         msg_Warn (p_this, "unknown or unsupported transport protocol "%s"",
  420.                   psz);
  421.     free (psz);
  422.     var_Create (p_this, "dccp-service", VLC_VAR_STRING);
  424.     if( ( p_sys->psz_destination == NULL ) && !b_rtsp )
  425.     {
  426.         msg_Err( p_stream, "missing destination and not in RTSP mode" );
  427.         free( p_sys );
  428.         return VLC_EGENERIC;
  429.     }
  431.     p_sys->i_ttl = var_GetInteger( p_stream, SOUT_CFG_PREFIX "ttl" );
  432.     if( p_sys->i_ttl == -1 )
  433.     {
  434.         /* Normally, we should let the default hop limit up to the core,
  435.          * but we have to know it to build our SDP properly, which is why
  436.          * we ask the core. FIXME: broken when neither sout-rtp-ttl nor
  437.          * ttl are set. */
  438.         p_sys->i_ttl = config_GetInt( p_stream, "ttl" );
  439.     }
  441.     p_sys->b_latm = var_GetBool( p_stream, SOUT_CFG_PREFIX "mp4a-latm" );
  443.     p_sys->payload_bitmap = 0;
  444.     p_sys->i_es = 0;
  445.     p_sys->es   = NULL;
  446.     p_sys->rtsp = NULL;
  447.     p_sys->psz_sdp = NULL;
  449.     p_sys->b_export_sap = false;
  450.     p_sys->b_export_sdp_file = false;
  451.     p_sys->p_session = NULL;
  453.     p_sys->p_httpd_host = NULL;
  454.     p_sys->p_httpd_file = NULL;
  456.     p_stream->p_sys     = p_sys;
  458.     vlc_mutex_init( &p_sys->lock_sdp );
  459.     vlc_mutex_init( &p_sys->lock_es );
  461.     psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "mux" );
  462.     if( psz != NULL )
  463.     {
  464.         sout_stream_id_t *id;
  466.         /* Check muxer type */
  467.         if( strncasecmp( psz, "ps", 2 )
  468.          && strncasecmp( psz, "mpeg1", 5 )
  469.          && strncasecmp( psz, "ts", 2 ) )
  470.         {
  471.             msg_Err( p_stream, "unsupported muxer type for RTP (only TS/PS)" );
  472.             free( psz );
  473.             vlc_mutex_destroy( &p_sys->lock_sdp );
  474.             vlc_mutex_destroy( &p_sys->lock_es );
  475.             free( p_sys->psz_destination );
  476.             free( p_sys );
  477.             return VLC_EGENERIC;
  478.         }
  480.         p_sys->p_grab = GrabberCreate( p_stream );
  481.         p_sys->p_mux = sout_MuxNew( p_sout, psz, p_sys->p_grab );
  482.         free( psz );
  484.         if( p_sys->p_mux == NULL )
  485.         {
  486.             msg_Err( p_stream, "cannot create muxer" );
  487.             sout_AccessOutDelete( p_sys->p_grab );
  488.             vlc_mutex_destroy( &p_sys->lock_sdp );
  489.             vlc_mutex_destroy( &p_sys->lock_es );
  490.             free( p_sys->psz_destination );
  491.             free( p_sys );
  492.             return VLC_EGENERIC;
  493.         }
  495.         id = Add( p_stream, NULL );
  496.         if( id == NULL )
  497.         {
  498.             sout_MuxDelete( p_sys->p_mux );
  499.             sout_AccessOutDelete( p_sys->p_grab );
  500.             vlc_mutex_destroy( &p_sys->lock_sdp );
  501.             vlc_mutex_destroy( &p_sys->lock_es );
  502.             free( p_sys->psz_destination );
  503.             free( p_sys );
  504.             return VLC_EGENERIC;
  505.         }
  507.         p_sys->packet = NULL;
  509.         p_stream->pf_add  = MuxAdd;
  510.         p_stream->pf_del  = MuxDel;
  511.         p_stream->pf_send = MuxSend;
  512.     }
  513.     else
  514.     {
  515.         p_sys->p_mux    = NULL;
  516.         p_sys->p_grab   = NULL;
  518.         p_stream->pf_add    = Add;
  519.         p_stream->pf_del    = Del;
  520.         p_stream->pf_send   = Send;
  521.     }
  523.     if( var_GetBool( p_stream, SOUT_CFG_PREFIX"sap" ) )
  524.         SDPHandleUrl( p_stream, "sap" );
  526.     psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "sdp" );
  527.     if( psz != NULL )
  528.     {
  529.         config_chain_t *p_cfg;
  531.         SDPHandleUrl( p_stream, psz );
  533.         for( p_cfg = p_stream->p_cfg; p_cfg != NULL; p_cfg = p_cfg->p_next )
  534.         {
  535.             if( !strcmp( p_cfg->psz_name, "sdp" ) )
  536.             {
  537.                 if( p_cfg->psz_value == NULL || *p_cfg->psz_value == '' )
  538.                     continue;
  540.                 /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
  541.                 if( !strcmp( p_cfg->psz_value, psz ) )
  542.                     continue;
  544.                 SDPHandleUrl( p_stream, p_cfg->psz_value );
  545.             }
  546.         }
  547.         free( psz );
  548.     }
  550.     /* update p_sout->i_out_pace_nocontrol */
  551.     p_stream->p_sout->i_out_pace_nocontrol++;
  553.     return VLC_SUCCESS;
  554. }
  556. /*****************************************************************************
  557.  * Close:
  558.  *****************************************************************************/
  559. static void Close( vlc_object_t * p_this )
  560. {
  561.     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
  562.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  564.     /* update p_sout->i_out_pace_nocontrol */
  565.     p_stream->p_sout->i_out_pace_nocontrol--;
  567.     if( p_sys->p_mux )
  568.     {
  569.         assert( p_sys->i_es == 1 );
  571.         sout_MuxDelete( p_sys->p_mux );
  572.         Del( p_stream, p_sys->es[0] );
  573.         sout_AccessOutDelete( p_sys->p_grab );
  575.         if( p_sys->packet )
  576.         {
  577.             block_Release( p_sys->packet );
  578.         }
  579.         if( p_sys->b_export_sap )
  580.         {
  581.             p_sys->p_mux = NULL;
  582.             SapSetup( p_stream );
  583.         }
  584.     }
  586.     if( p_sys->rtsp != NULL )
  587.         RtspUnsetup( p_sys->rtsp );
  589.     vlc_mutex_destroy( &p_sys->lock_sdp );
  590.     vlc_mutex_destroy( &p_sys->lock_es );
  592.     if( p_sys->p_httpd_file )
  593.         httpd_FileDelete( p_sys->p_httpd_file );
  595.     if( p_sys->p_httpd_host )
  596.         httpd_HostDelete( p_sys->p_httpd_host );
  598.     free( p_sys->psz_sdp );
  600.     if( p_sys->b_export_sdp_file )
  601.     {
  602. #ifdef HAVE_UNISTD_H
  603.         unlink( p_sys->psz_sdp_file );
  604. #endif
  605.         free( p_sys->psz_sdp_file );
  606.     }
  607.     free( p_sys->psz_destination );
  608.     free( p_sys );
  609. }
  611. /*****************************************************************************
  612.  * SDPHandleUrl:
  613.  *****************************************************************************/
  614. static void SDPHandleUrl( sout_stream_t *p_stream, const char *psz_url )
  615. {
  616.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  617.     vlc_url_t url;
  619.     vlc_UrlParse( &url, psz_url, 0 );
  620.     if( url.psz_protocol && !strcasecmp( url.psz_protocol, "http" ) )
  621.     {
  622.         if( p_sys->p_httpd_file )
  623.         {
  624.             msg_Err( p_stream, "you can use sdp=http:// only once" );
  625.             goto out;
  626.         }
  628.         if( HttpSetup( p_stream, &url ) )
  629.         {
  630.             msg_Err( p_stream, "cannot export SDP as HTTP" );
  631.         }
  632.     }
  633.     else if( url.psz_protocol && !strcasecmp( url.psz_protocol, "rtsp" ) )
  634.     {
  635.         if( p_sys->rtsp != NULL )
  636.         {
  637.             msg_Err( p_stream, "you can use sdp=rtsp:// only once" );
  638.             goto out;
  639.         }
  641.         /* FIXME test if destination is multicast or no destination at all */
  642.         p_sys->rtsp = RtspSetup( p_stream, &url );
  643.         if( p_sys->rtsp == NULL )
  644.             msg_Err( p_stream, "cannot export SDP as RTSP" );
  645.         else
  646.         if( p_sys->p_mux != NULL )
  647.         {
  648.             sout_stream_id_t *id = p_sys->es[0];
  649.             id->rtsp_id = RtspAddId( p_sys->rtsp, id, 0, GetDWBE( id->ssrc ),
  650.                                      p_sys->psz_destination, p_sys->i_ttl,
  651.                                      id->i_port, id->i_port + 1 );
  652.         }
  653.     }
  654.     else if( ( url.psz_protocol && !strcasecmp( url.psz_protocol, "sap" ) ) ||
  655.              ( url.psz_host && !strcasecmp( url.psz_host, "sap" ) ) )
  656.     {
  657.         p_sys->b_export_sap = true;
  658.         SapSetup( p_stream );
  659.     }
  660.     else if( url.psz_protocol && !strcasecmp( url.psz_protocol, "file" ) )
  661.     {
  662.         if( p_sys->b_export_sdp_file )
  663.         {
  664.             msg_Err( p_stream, "you can use sdp=file:// only once" );
  665.             goto out;
  666.         }
  667.         p_sys->b_export_sdp_file = true;
  668.         psz_url = &psz_url[5];
  669.         if( psz_url[0] == '/' && psz_url[1] == '/' )
  670.             psz_url += 2;
  671.         p_sys->psz_sdp_file = strdup( psz_url );
  672.         decode_URI( p_sys->psz_sdp_file ); /* FIXME? */
  673.         FileSetup( p_stream );
  674.     }
  675.     else
  676.     {
  677.         msg_Warn( p_stream, "unknown protocol for SDP (%s)",
  678.                   url.psz_protocol );
  679.     }
  681. out:
  682.     vlc_UrlClean( &url );
  683. }
  685. /*****************************************************************************
  686.  * SDPGenerate
  687.  *****************************************************************************/
  688. /*static*/
  689. char *SDPGenerate( const sout_stream_t *p_stream, const char *rtsp_url )
  690. {
  691.     const sout_stream_sys_t *p_sys = p_stream->p_sys;
  692.     char *psz_sdp;
  693.     struct sockaddr_storage dst;
  694.     socklen_t dstlen;
  695.     int i;
  696.     /*
  697.      * When we have a fixed destination (typically when we do multicast),
  698.      * we need to put the actual port numbers in the SDP.
  699.      * When there is no fixed destination, we only support RTSP unicast
  700.      * on-demand setup, so we should rather let the clients decide which ports
  701.      * to use.
  702.      * When there is both a fixed destination and RTSP unicast, we need to
  703.      * put port numbers used by the fixed destination, otherwise the SDP would
  704.      * become totally incorrect for multicast use. It should be noted that
  705.      * port numbers from SDP with RTSP are only "recommendation" from the
  706.      * server to the clients (per RFC2326), so only broken clients will fail
  707.      * to handle this properly. There is no solution but to use two differents
  708.      * output chain with two different RTSP URLs if you need to handle this
  709.      * scenario.
  710.      */
  711.     int inclport;
  713.     if( p_sys->psz_destination != NULL )
  714.     {
  715.         inclport = 1;
  717.         /* Oh boy, this is really ugly! (+ race condition on lock_es) */
  718.         dstlen = sizeof( dst );
  719.         if( p_sys->es[0]->listen_fd != NULL )
  720.             getsockname( p_sys->es[0]->listen_fd[0],
  721.                          (struct sockaddr *)&dst, &dstlen );
  722.         else
  723.             getpeername( p_sys->es[0]->sinkv[0].rtp_fd,
  724.                          (struct sockaddr *)&dst, &dstlen );
  725.     }
  726.     else
  727.     {
  728.         inclport = 0;
  730.         /* Dummy destination address for RTSP */
  731.         memset (&dst, 0, sizeof( struct sockaddr_in ) );
  732.         dst.ss_family = AF_INET;
  733. #ifdef HAVE_SA_LEN
  734.         dst.ss_len =
  735. #endif
  736.         dstlen = sizeof( struct sockaddr_in );
  737.     }
  739.     psz_sdp = vlc_sdp_Start( VLC_OBJECT( p_stream ), SOUT_CFG_PREFIX,
  740.                              NULL, 0, (struct sockaddr *)&dst, dstlen );
  741.     if( psz_sdp == NULL )
  742.         return NULL;
  744.     /* TODO: a=source-filter */
  745.     if( p_sys->rtcp_mux )
  746.         sdp_AddAttribute( &psz_sdp, "rtcp-mux", NULL );
  748.     if( rtsp_url != NULL )
  749.         sdp_AddAttribute ( &psz_sdp, "control", "%s", rtsp_url );
  751.     /* FIXME: locking?! */
  752.     for( i = 0; i < p_sys->i_es; i++ )
  753.     {
  754.         sout_stream_id_t *id = p_sys->es[i];
  755.         const char *mime_major; /* major MIME type */
  756.         const char *proto = "RTP/AVP"; /* protocol */
  758.         switch( id->i_cat )
  759.         {
  760.             case VIDEO_ES:
  761.                 mime_major = "video";
  762.                 break;
  763.             case AUDIO_ES:
  764.                 mime_major = "audio";
  765.                 break;
  766.             case SPU_ES:
  767.                 mime_major = "text";
  768.                 break;
  769.             default:
  770.                 continue;
  771.         }
  773.         if( rtsp_url == NULL )
  774.         {
  775.             switch( p_sys->proto )
  776.             {
  777.                 case IPPROTO_UDP:
  778.                     break;
  779.                 case IPPROTO_TCP:
  780.                     proto = "TCP/RTP/AVP";
  781.                     break;
  782.                 case IPPROTO_DCCP:
  783.                     proto = "DCCP/RTP/AVP";
  784.                     break;
  785.                 case IPPROTO_UDPLITE:
  786.                     continue;
  787.             }
  788.         }
  790.         sdp_AddMedia( &psz_sdp, mime_major, proto, inclport * id->i_port,
  791.                       id->i_payload_type, false, id->i_bitrate,
  792.                       id->psz_enc, id->i_clock_rate, id->i_channels,
  793.                       id->psz_fmtp);
  795.         if( !p_sys->rtcp_mux && (id->i_port & 1) ) /* cf RFC4566 §5.14 */
  796.             sdp_AddAttribute ( &psz_sdp, "rtcp", "%u", id->i_port + 1 );
  798.         if( rtsp_url != NULL )
  799.         {
  800.             assert( strlen( rtsp_url ) > 0 );
  801.             bool addslash = ( rtsp_url[strlen( rtsp_url ) - 1] != '/' );
  802.             sdp_AddAttribute ( &psz_sdp, "control",
  803.                                addslash ? "%s/trackID=%u" : "%strackID=%u",
  804.                                rtsp_url, i );
  805.         }
  806.         else
  807.         {
  808.             if( id->listen_fd != NULL )
  809.                 sdp_AddAttribute( &psz_sdp, "setup", "passive" );
  810.             if( p_sys->proto == IPPROTO_DCCP )
  811.                 sdp_AddAttribute( &psz_sdp, "dccp-service-code",
  812.                                   "SC:RTP%c", toupper( mime_major[0] ) );
  813.         }
  814.     }
  816.     return psz_sdp;
  817. }
  819. /*****************************************************************************
  820.  * RTP mux
  821.  *****************************************************************************/
  823. static void sprintf_hexa( char *s, uint8_t *p_data, int i_data )
  824. {
  825.     static const char hex[16] = "0123456789abcdef";
  826.     int i;
  828.     for( i = 0; i < i_data; i++ )
  829.     {
  830.         s[2*i+0] = hex[(p_data[i]>>4)&0xf];
  831.         s[2*i+1] = hex[(p_data[i]   )&0xf];
  832.     }
  833.     s[2*i_data] = '';
  834. }
  836. /**
  837.  * Shrink the MTU down to a fixed packetization time (for audio).
  838.  */
  839. static void
  840. rtp_set_ptime (sout_stream_id_t *id, unsigned ptime_ms, size_t bytes)
  841. {
  842.     /* Samples per second */
  843.     size_t spl = (id->i_clock_rate - 1) * ptime_ms / 1000 + 1;
  844.     bytes *= id->i_channels;
  845.     spl *= bytes;
  847.     if (spl < rtp_mtu (id)) /* MTU is big enough for ptime */
  848.         id->i_mtu = 12 + spl;
  849.     else /* MTU is too small for ptime, align to a sample boundary */
  850.         id->i_mtu = 12 + (((id->i_mtu - 12) / bytes) * bytes);
  851. }
  853. /** Add an ES as a new RTP stream */
  854. static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
  855. {
  856.     /* NOTE: As a special case, if we use a non-RTP
  857.      * mux (TS/PS), then p_fmt is NULL. */
  858.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  859.     sout_stream_id_t  *id;
  860.     int               cscov = -1;
  861.     char              *psz_sdp;
  863.     if (0xffffffff == p_sys->payload_bitmap)
  864.     {
  865.         msg_Err (p_stream, "too many RTP elementary streams");
  866.         return NULL;
  867.     }
  869.     /* Choose the port */
  870.     uint16_t i_port = 0;
  871.     if( p_fmt == NULL )
  872.         ;
  873.     else
  874.     if( p_fmt->i_cat == AUDIO_ES && p_sys->i_port_audio > 0 )
  875.         i_port = p_sys->i_port_audio;
  876.     else
  877.     if( p_fmt->i_cat == VIDEO_ES && p_sys->i_port_video > 0 )
  878.         i_port = p_sys->i_port_video;
  880.     /* We do not need the ES lock (p_sys->lock_es) here, because this is the
  881.      * only one thread that can *modify* the ES table. The ES lock protects
  882.      * the other threads from our modifications (TAB_APPEND, TAB_REMOVE). */
  883.     for (int i = 0; i_port && (i < p_sys->i_es); i++)
  884.          if (i_port == p_sys->es[i]->i_port)
  885.              i_port = 0; /* Port already in use! */
  886.     for (uint16_t p = p_sys->i_port; i_port == 0; p += 2)
  887.     {
  888.         if (p == 0)
  889.         {
  890.             msg_Err (p_stream, "too many RTP elementary streams");
  891.             return NULL;
  892.         }
  893.         i_port = p;
  894.         for (int i = 0; i_port && (i < p_sys->i_es); i++)
  895.              if (p == p_sys->es[i]->i_port)
  896.                  i_port = 0;
  897.     }
  899.     id = vlc_object_create( p_stream, sizeof( sout_stream_id_t ) );
  900.     if( id == NULL )
  901.         return NULL;
  902.     vlc_object_attach( id, p_stream );
  904.     id->p_stream   = p_stream;
  906.     id->i_timestamp = 0; /* It will be filled when the first packet is sent */
  908.     /* Look for free dymanic payload type */
  909.     id->i_payload_type = 96;
  910.     while (p_sys->payload_bitmap & (1 << (id->i_payload_type - 96)))
  911.         id->i_payload_type++;
  912.     assert (id->i_payload_type < 128);
  914.     vlc_rand_bytes (&id->i_sequence, sizeof (id->i_sequence));
  915.     vlc_rand_bytes (id->ssrc, sizeof (id->ssrc));
  917.     id->psz_enc    = NULL;
  918.     id->psz_fmtp   = NULL;
  919.     id->i_clock_rate = 90000; /* most common case for video */
  920.     id->i_channels = 0;
  921.     id->i_port     = i_port;
  922.     if( p_fmt != NULL )
  923.     {
  924.         id->i_cat  = p_fmt->i_cat;
  925.         if( p_fmt->i_cat == AUDIO_ES )
  926.         {
  927.             id->i_clock_rate = p_fmt->audio.i_rate;
  928.             id->i_channels = p_fmt->audio.i_channels;
  929.         }
  930.         id->i_bitrate = p_fmt->i_bitrate/1000; /* Stream bitrate in kbps */
  931.     }
  932.     else
  933.     {
  934.         id->i_cat  = VIDEO_ES;
  935.         id->i_bitrate = 0;
  936.     }
  938.     id->i_mtu = config_GetInt( p_stream, "mtu" );
  939.     if( id->i_mtu <= 12 + 16 )
  940.         id->i_mtu = 576 - 20 - 8; /* pessimistic */
  941.     msg_Dbg( p_stream, "maximum RTP packet size: %d bytes", id->i_mtu );
  943.     id->srtp = NULL;
  944.     id->pf_packetize = NULL;
  946.     char *key = var_CreateGetNonEmptyString (p_stream, SOUT_CFG_PREFIX"key");
  947.     if (key)
  948.     {
  949.         id->srtp = srtp_create (SRTP_ENCR_AES_CM, SRTP_AUTH_HMAC_SHA1, 10,
  950.                                    SRTP_PRF_AES_CM, SRTP_RCC_MODE1);
  951.         if (id->srtp == NULL)
  952.         {
  953.             free (key);
  954.             goto error;
  955.         }
  957.         char *salt = var_CreateGetNonEmptyString (p_stream, SOUT_CFG_PREFIX"salt");
  958.         errno = srtp_setkeystring (id->srtp, key, salt ? salt : "");
  959.         free (salt);
  960.         free (key);
  961.         if (errno)
  962.         {
  963.             msg_Err (p_stream, "bad SRTP key/salt combination (%m)");
  964.             goto error;
  965.         }
  966.         id->i_sequence = 0; /* FIXME: awful hack for libvlc_srtp */
  967.     }
  969.     vlc_mutex_init( &id->lock_sink );
  970.     id->sinkc = 0;
  971.     id->sinkv = NULL;
  972.     id->rtsp_id = NULL;
  973.     id->p_fifo = NULL;
  974.     id->listen_fd = NULL;
  976.     id->i_caching =
  977.         (int64_t)1000 * var_GetInteger( p_stream, SOUT_CFG_PREFIX "caching");
  979.     if( p_sys->psz_destination != NULL )
  980.         switch( p_sys->proto )
  981.         {
  982.             case IPPROTO_DCCP:
  983.             {
  984.                 const char *code;
  985.                 switch (id->i_cat)
  986.                 {
  987.                     case VIDEO_ES: code = "RTPV";     break;
  988.                     case AUDIO_ES: code = "RTPARTPV"; break;
  989.                     case SPU_ES:   code = "RTPTRTPV"; break;
  990.                     default:       code = "RTPORTPV"; break;
  991.                 }
  992.                 var_SetString (p_stream, "dccp-service", code);
  993.             }   /* fall through */
  994.             case IPPROTO_TCP:
  995.                 id->listen_fd = net_Listen( VLC_OBJECT(p_stream),
  996.                                             p_sys->psz_destination, i_port,
  997.                                             p_sys->proto );
  998.                 if( id->listen_fd == NULL )
  999.                 {
  1000.                     msg_Err( p_stream, "passive COMEDIA RTP socket failed" );
  1001.                     goto error;
  1002.                 }
  1003.                 break;
  1005.             default:
  1006.             {
  1007.                 int ttl = (p_sys->i_ttl >= 0) ? p_sys->i_ttl : -1;
  1008.                 int fd = net_ConnectDgram( p_stream, p_sys->psz_destination,
  1009.                                            i_port, ttl, p_sys->proto );
  1010.                 if( fd == -1 )
  1011.                 {
  1012.                     msg_Err( p_stream, "cannot create RTP socket" );
  1013.                     goto error;
  1014.                 }
  1015.                 rtp_add_sink( id, fd, p_sys->rtcp_mux );
  1016.             }
  1017.         }
  1019.     if( p_fmt == NULL )
  1020.     {
  1021.         char *psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "mux" );
  1023.         if( psz == NULL ) /* Uho! */
  1024.             ;
  1025.         else
  1026.         if( strncmp( psz, "ts", 2 ) == 0 )
  1027.         {
  1028.             id->i_payload_type = 33;
  1029.             id->psz_enc = "MP2T";
  1030.         }
  1031.         else
  1032.         {
  1033.             id->psz_enc = "MP2P";
  1034.         }
  1035.         free( psz );
  1036.     }
  1037.     else
  1038.     switch( p_fmt->i_codec )
  1039.     {
  1040.         case VLC_FOURCC( 'u', 'l', 'a', 'w' ):
  1041.             if( p_fmt->audio.i_channels == 1 && p_fmt->audio.i_rate == 8000 )
  1042.                 id->i_payload_type = 0;
  1043.             id->psz_enc = "PCMU";
  1044.             id->pf_packetize = rtp_packetize_split;
  1045.             rtp_set_ptime (id, 20, 1);
  1046.             break;
  1047.         case VLC_FOURCC( 'a', 'l', 'a', 'w' ):
  1048.             if( p_fmt->audio.i_channels == 1 && p_fmt->audio.i_rate == 8000 )
  1049.                 id->i_payload_type = 8;
  1050.             id->psz_enc = "PCMA";
  1051.             id->pf_packetize = rtp_packetize_split;
  1052.             rtp_set_ptime (id, 20, 1);
  1053.             break;
  1054.         case VLC_FOURCC( 's', '1', '6', 'b' ):
  1055.             if( p_fmt->audio.i_channels == 1 && p_fmt->audio.i_rate == 44100 )
  1056.             {
  1057.                 id->i_payload_type = 11;
  1058.             }
  1059.             else if( p_fmt->audio.i_channels == 2 &&
  1060.                      p_fmt->audio.i_rate == 44100 )
  1061.             {
  1062.                 id->i_payload_type = 10;
  1063.             }
  1064.             id->psz_enc = "L16";
  1065.             id->pf_packetize = rtp_packetize_split;
  1066.             rtp_set_ptime (id, 20, 2);
  1067.             break;
  1068.         case VLC_FOURCC( 'u', '8', ' ', ' ' ):
  1069.             id->psz_enc = "L8";
  1070.             id->pf_packetize = rtp_packetize_split;
  1071.             rtp_set_ptime (id, 20, 1);
  1072.             break;
  1073.         case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
  1074.         case VLC_FOURCC( 'm', 'p', '3', ' ' ):
  1075.             id->i_payload_type = 14;
  1076.             id->psz_enc = "MPA";
  1077.             id->i_clock_rate = 90000; /* not 44100 */
  1078.             id->pf_packetize = rtp_packetize_mpa;
  1079.             break;
  1080.         case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
  1081.             id->i_payload_type = 32;
  1082.             id->psz_enc = "MPV";
  1083.             id->pf_packetize = rtp_packetize_mpv;
  1084.             break;
  1085.         case VLC_FOURCC( 'G', '7', '2', '6' ):
  1086.         case VLC_FOURCC( 'g', '7', '2', '6' ):
  1087.             switch( p_fmt->i_bitrate / 1000 )
  1088.             {
  1089.             case 16:
  1090.                 id->psz_enc = "G726-16";
  1091.                 id->pf_packetize = rtp_packetize_g726_16;
  1092.                 break;
  1093.             case 24:
  1094.                 id->psz_enc = "G726-24";
  1095.                 id->pf_packetize = rtp_packetize_g726_24;
  1096.                 break;
  1097.             case 32:
  1098.                 id->psz_enc = "G726-32";
  1099.                 id->pf_packetize = rtp_packetize_g726_32;
  1100.                 break;
  1101.             case 40:
  1102.                 id->psz_enc = "G726-40";
  1103.                 id->pf_packetize = rtp_packetize_g726_40;
  1104.                 break;
  1105.             default:
  1106.                 msg_Err( p_stream, "cannot add this stream (unsupported "
  1107.                          "G.726 bit rate: %u)", p_fmt->i_bitrate );
  1108.                 goto error;
  1109.             }
  1110.             break;
  1111.         case VLC_FOURCC( 'a', '5', '2', ' ' ):
  1112.             id->psz_enc = "ac3";
  1113.             id->pf_packetize = rtp_packetize_ac3;
  1114.             break;
  1115.         case VLC_FOURCC( 'H', '2', '6', '3' ):
  1116.             id->psz_enc = "H263-1998";
  1117.             id->pf_packetize = rtp_packetize_h263;
  1118.             break;
  1119.         case VLC_FOURCC( 'h', '2', '6', '4' ):
  1120.             id->psz_enc = "H264";
  1121.             id->pf_packetize = rtp_packetize_h264;
  1122.             id->psz_fmtp = NULL;
  1124.             if( p_fmt->i_extra > 0 )
  1125.             {
  1126.                 uint8_t *p_buffer = p_fmt->p_extra;
  1127.                 int     i_buffer = p_fmt->i_extra;
  1128.                 char    *p_64_sps = NULL;
  1129.                 char    *p_64_pps = NULL;
  1130.                 char    hexa[6+1];
  1132.                 while( i_buffer > 4 &&
  1133.                        p_buffer[0] == 0 && p_buffer[1] == 0 &&
  1134.                        p_buffer[2] == 0 && p_buffer[3] == 1 )
  1135.                 {
  1136.                     const int i_nal_type = p_buffer[4]&0x1f;
  1137.                     int i_offset;
  1138.                     int i_size      = 0;
  1140.                     msg_Dbg( p_stream, "we found a startcode for NAL with TYPE:%d", i_nal_type );
  1142.                     i_size = i_buffer;
  1143.                     for( i_offset = 4; i_offset+3 < i_buffer ; i_offset++)
  1144.                     {
  1145.                         if( !memcmp (p_buffer + i_offset, "x00x00x00x01", 4 ) )
  1146.                         {
  1147.                             /* we found another startcode */
  1148.                             i_size = i_offset;
  1149.                             break;
  1150.                         }
  1151.                     }
  1152.                     if( i_nal_type == 7 )
  1153.                     {
  1154.                         p_64_sps = vlc_b64_encode_binary( &p_buffer[4], i_size - 4 );
  1155.                         sprintf_hexa( hexa, &p_buffer[5], 3 );
  1156.                     }
  1157.                     else if( i_nal_type == 8 )
  1158.                     {
  1159.                         p_64_pps = vlc_b64_encode_binary( &p_buffer[4], i_size - 4 );
  1160.                     }
  1161.                     i_buffer -= i_size;
  1162.                     p_buffer += i_size;
  1163.                 }
  1164.                 /* */
  1165.                 if( p_64_sps && p_64_pps &&
  1166.                     ( asprintf( &id->psz_fmtp,
  1167.                                 "packetization-mode=1;profile-level-id=%s;"
  1168.                                 "sprop-parameter-sets=%s,%s;", hexa, p_64_sps,
  1169.                                 p_64_pps ) == -1 ) )
  1170.                     id->psz_fmtp = NULL;
  1171.                 free( p_64_sps );
  1172.                 free( p_64_pps );
  1173.             }
  1174.             if( !id->psz_fmtp )
  1175.                 id->psz_fmtp = strdup( "packetization-mode=1" );
  1176.             break;
  1178.         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
  1179.         {
  1180.             char hexa[2*p_fmt->i_extra +1];
  1182.             id->psz_enc = "MP4V-ES";
  1183.             id->pf_packetize = rtp_packetize_split;
  1184.             if( p_fmt->i_extra > 0 )
  1185.             {
  1186.                 sprintf_hexa( hexa, p_fmt->p_extra, p_fmt->i_extra );
  1187.                 if( asprintf( &id->psz_fmtp,
  1188.                               "profile-level-id=3; config=%s;", hexa ) == -1 )
  1189.                     id->psz_fmtp = NULL;
  1190.             }
  1191.             break;
  1192.         }
  1193.         case VLC_FOURCC( 'm', 'p', '4', 'a' ):
  1194.         {
  1195.             if(!p_sys->b_latm)
  1196.             {
  1197.                 char hexa[2*p_fmt->i_extra +1];
  1199.                 id->psz_enc = "mpeg4-generic";
  1200.                 id->pf_packetize = rtp_packetize_mp4a;
  1201.                 sprintf_hexa( hexa, p_fmt->p_extra, p_fmt->i_extra );
  1202.                 if( asprintf( &id->psz_fmtp,
  1203.                               "streamtype=5; profile-level-id=15; "
  1204.                               "mode=AAC-hbr; config=%s; SizeLength=13; "
  1205.                               "IndexLength=3; IndexDeltaLength=3; Profile=1;",
  1206.                               hexa ) == -1 )
  1207.                     id->psz_fmtp = NULL;
  1208.             }
  1209.             else
  1210.             {
  1211.                 char hexa[13];
  1212.                 int i;
  1213.                 unsigned char config[6];
  1214.                 unsigned int aacsrates[15] = {
  1215.                     96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
  1216.                     16000, 12000, 11025, 8000, 7350, 0, 0 };
  1218.                 for( i = 0; i < 15; i++ )
  1219.                     if( p_fmt->audio.i_rate == aacsrates[i] )
  1220.                         break;
  1222.                 config[0]=0x40;
  1223.                 config[1]=0;
  1224.                 config[2]=0x20|i;
  1225.                 config[3]=p_fmt->audio.i_channels<<4;
  1226.                 config[4]=0x3f;
  1227.                 config[5]=0xc0;
  1229.                 id->psz_enc = "MP4A-LATM";
  1230.                 id->pf_packetize = rtp_packetize_mp4a_latm;
  1231.                 sprintf_hexa( hexa, config, 6 );
  1232.                 if( asprintf( &id->psz_fmtp, "profile-level-id=15; "
  1233.                               "object=2; cpresent=0; config=%s", hexa ) == -1 )
  1234.                     id->psz_fmtp = NULL;
  1235.             }
  1236.             break;
  1237.         }
  1238.         case VLC_FOURCC( 's', 'a', 'm', 'r' ):
  1239.             id->psz_enc = "AMR";
  1240.             id->psz_fmtp = strdup( "octet-align=1" );
  1241.             id->pf_packetize = rtp_packetize_amr;
  1242.             break;
  1243.         case VLC_FOURCC( 's', 'a', 'w', 'b' ):
  1244.             id->psz_enc = "AMR-WB";
  1245.             id->psz_fmtp = strdup( "octet-align=1" );
  1246.             id->pf_packetize = rtp_packetize_amr;
  1247.             break;
  1248.         case VLC_FOURCC( 's', 'p', 'x', ' ' ):
  1249.             id->psz_enc = "SPEEX";
  1250.             id->pf_packetize = rtp_packetize_spx;
  1251.             break;
  1252.         case VLC_FOURCC( 't', '1', '4', '0' ):
  1253.             id->psz_enc = "t140" ;
  1254.             id->i_clock_rate = 1000;
  1255.             id->pf_packetize = rtp_packetize_t140;
  1256.             break;
  1258.         default:
  1259.             msg_Err( p_stream, "cannot add this stream (unsupported "
  1260.                      "codec: %4.4s)", (char*)&p_fmt->i_codec );
  1261.             goto error;
  1262.     }
  1263.     if (id->i_payload_type >= 96)
  1264.         /* Mark dynamic payload type in use */
  1265.         p_sys->payload_bitmap |= 1 << (id->i_payload_type - 96);
  1267. #if 0 /* No payload formats sets this at the moment */
  1268.     if( cscov != -1 )
  1269.         cscov += 8 /* UDP */ + 12 /* RTP */;
  1270.     if( id->sinkc > 0 )
  1271.         net_SetCSCov( id->sinkv[0].rtp_fd, cscov, -1 );
  1272. #endif
  1274.     if( p_sys->rtsp != NULL )
  1275.         id->rtsp_id = RtspAddId( p_sys->rtsp, id, p_sys->i_es,
  1276.                                  GetDWBE( id->ssrc ),
  1277.                                  p_sys->psz_destination,
  1278.                                  p_sys->i_ttl, id->i_port, id->i_port + 1 );
  1280.     id->p_fifo = block_FifoNew();
  1281.     if( vlc_thread_create( id, "RTP send thread", ThreadSend,
  1282.                            VLC_THREAD_PRIORITY_HIGHEST ) )
  1283.         goto error;
  1285.     /* Update p_sys context */
  1286.     vlc_mutex_lock( &p_sys->lock_es );
  1287.     TAB_APPEND( p_sys->i_es, p_sys->es, id );
  1288.     vlc_mutex_unlock( &p_sys->lock_es );
  1290.     psz_sdp = SDPGenerate( p_stream, NULL );
  1292.     vlc_mutex_lock( &p_sys->lock_sdp );
  1293.     free( p_sys->psz_sdp );
  1294.     p_sys->psz_sdp = psz_sdp;
  1295.     vlc_mutex_unlock( &p_sys->lock_sdp );
  1297.     msg_Dbg( p_stream, "sdp=n%s", p_sys->psz_sdp );
  1299.     /* Update SDP (sap/file) */
  1300.     if( p_sys->b_export_sap ) SapSetup( p_stream );
  1301.     if( p_sys->b_export_sdp_file ) FileSetup( p_stream );
  1303.     return id;
  1305. error:
  1306.     Del( p_stream, id );
  1307.     return NULL;
  1308. }
  1310. static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
  1311. {
  1312.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  1314.     if( id->p_fifo != NULL )
  1315.     {
  1316.         vlc_object_kill( id );
  1317.         vlc_thread_join( id );
  1318.         block_FifoRelease( id->p_fifo );
  1319.     }
  1321.     vlc_mutex_lock( &p_sys->lock_es );
  1322.     TAB_REMOVE( p_sys->i_es, p_sys->es, id );
  1323.     vlc_mutex_unlock( &p_sys->lock_es );
  1325.     /* Release dynamic payload type */
  1326.     if (id->i_payload_type >= 96)
  1327.         p_sys->payload_bitmap &= ~(1 << (id->i_payload_type - 96));
  1329.     free( id->psz_fmtp );
  1331.     if( id->rtsp_id )
  1332.         RtspDelId( p_sys->rtsp, id->rtsp_id );
  1333.     if( id->sinkc > 0 )
  1334.         rtp_del_sink( id, id->sinkv[0].rtp_fd ); /* sink for explicit dst= */
  1335.     if( id->listen_fd != NULL )
  1336.         net_ListenClose( id->listen_fd );
  1337.     if( id->srtp != NULL )
  1338.         srtp_destroy( id->srtp );
  1340.     vlc_mutex_destroy( &id->lock_sink );
  1342.     /* Update SDP (sap/file) */
  1343.     if( p_sys->b_export_sap && !p_sys->p_mux ) SapSetup( p_stream );
  1344.     if( p_sys->b_export_sdp_file ) FileSetup( p_stream );
  1346.     vlc_object_detach( id );
  1347.     vlc_object_release( id );
  1348.     return VLC_SUCCESS;
  1349. }
  1351. static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
  1352.                  block_t *p_buffer )
  1353. {
  1354.     block_t *p_next;
  1356.     assert( p_stream->p_sys->p_mux == NULL );
  1357.     (void)p_stream;
  1359.     while( p_buffer != NULL )
  1360.     {
  1361.         p_next = p_buffer->p_next;
  1362.         if( id->pf_packetize( id, p_buffer ) )
  1363.             break;
  1365.         block_Release( p_buffer );
  1366.         p_buffer = p_next;
  1367.     }
  1368.     return VLC_SUCCESS;
  1369. }
  1371. /****************************************************************************
  1372.  * SAP:
  1373.  ****************************************************************************/
  1374. static int SapSetup( sout_stream_t *p_stream )
  1375. {
  1376.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  1377.     sout_instance_t   *p_sout = p_stream->p_sout;
  1379.     /* Remove the previous session */
  1380.     if( p_sys->p_session != NULL)
  1381.     {
  1382.         sout_AnnounceUnRegister( p_sout, p_sys->p_session);
  1383.         p_sys->p_session = NULL;
  1384.     }
  1386.     if( ( p_sys->i_es > 0 || p_sys->p_mux ) && p_sys->psz_sdp && *p_sys->psz_sdp )
  1387.     {
  1388.         announce_method_t *p_method = sout_SAPMethod();
  1389.         p_sys->p_session = sout_AnnounceRegisterSDP( p_sout,
  1390.                                                      p_sys->psz_sdp,
  1391.                                                      p_sys->psz_destination,
  1392.                                                      p_method );
  1393.         sout_MethodRelease( p_method );
  1394.     }
  1396.     return VLC_SUCCESS;
  1397. }
  1399. /****************************************************************************
  1400. * File:
  1401. ****************************************************************************/
  1402. static int FileSetup( sout_stream_t *p_stream )
  1403. {
  1404.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  1405.     FILE            *f;
  1407.     if( p_sys->psz_sdp == NULL )
  1408.         return VLC_EGENERIC; /* too early */
  1410.     if( ( f = utf8_fopen( p_sys->psz_sdp_file, "wt" ) ) == NULL )
  1411.     {
  1412.         msg_Err( p_stream, "cannot open file '%s' (%m)",
  1413.                  p_sys->psz_sdp_file );
  1414.         return VLC_EGENERIC;
  1415.     }
  1417.     fputs( p_sys->psz_sdp, f );
  1418.     fclose( f );
  1420.     return VLC_SUCCESS;
  1421. }
  1423. /****************************************************************************
  1424.  * HTTP:
  1425.  ****************************************************************************/
  1426. static int  HttpCallback( httpd_file_sys_t *p_args,
  1427.                           httpd_file_t *, uint8_t *p_request,
  1428.                           uint8_t **pp_data, int *pi_data );
  1430. static int HttpSetup( sout_stream_t *p_stream, const vlc_url_t *url)
  1431. {
  1432.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  1434.     p_sys->p_httpd_host = httpd_HostNew( VLC_OBJECT(p_stream), url->psz_host,
  1435.                                          url->i_port > 0 ? url->i_port : 80 );
  1436.     if( p_sys->p_httpd_host )
  1437.     {
  1438.         p_sys->p_httpd_file = httpd_FileNew( p_sys->p_httpd_host,
  1439.                                              url->psz_path ? url->psz_path : "/",
  1440.                                              "application/sdp",
  1441.                                              NULL, NULL, NULL,
  1442.                                              HttpCallback, (void*)p_sys );
  1443.     }
  1444.     if( p_sys->p_httpd_file == NULL )
  1445.     {
  1446.         return VLC_EGENERIC;
  1447.     }
  1448.     return VLC_SUCCESS;
  1449. }
  1451. static int  HttpCallback( httpd_file_sys_t *p_args,
  1452.                           httpd_file_t *f, uint8_t *p_request,
  1453.                           uint8_t **pp_data, int *pi_data )
  1454. {
  1455.     VLC_UNUSED(f); VLC_UNUSED(p_request);
  1456.     sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_args;
  1458.     vlc_mutex_lock( &p_sys->lock_sdp );
  1459.     if( p_sys->psz_sdp && *p_sys->psz_sdp )
  1460.     {
  1461.         *pi_data = strlen( p_sys->psz_sdp );
  1462.         *pp_data = malloc( *pi_data );
  1463.         memcpy( *pp_data, p_sys->psz_sdp, *pi_data );
  1464.     }
  1465.     else
  1466.     {
  1467.         *pp_data = NULL;
  1468.         *pi_data = 0;
  1469.     }
  1470.     vlc_mutex_unlock( &p_sys->lock_sdp );
  1472.     return VLC_SUCCESS;
  1473. }
  1475. /****************************************************************************
  1476.  * RTP send
  1477.  ****************************************************************************/
  1478. static void* ThreadSend( vlc_object_t *p_this )
  1479. {
  1480. #ifdef WIN32
  1481. # define ECONNREFUSED WSAECONNREFUSED
  1482. # define ENOPROTOOPT  WSAENOPROTOOPT
  1483. # define EHOSTUNREACH WSAEHOSTUNREACH
  1484. # define ENETUNREACH  WSAENETUNREACH
  1485. # define ENETDOWN     WSAENETDOWN
  1486. # define ENOBUFS      WSAENOBUFS
  1487. # define EAGAIN       WSAEWOULDBLOCK
  1488. # define EWOULDBLOCK  WSAEWOULDBLOCK
  1489. #endif
  1490.     sout_stream_id_t *id = (sout_stream_id_t *)p_this;
  1491.     unsigned i_caching = id->i_caching;
  1493.     for (;;)
  1494.     {
  1495.         block_t *out = block_FifoGet( id->p_fifo );
  1496.         block_cleanup_push (out);
  1498.         if( id->srtp )
  1499.         {   /* FIXME: this is awfully inefficient */
  1500.             size_t len = out->i_buffer;
  1501.             out = block_Realloc( out, 0, len + 10 );
  1502.             out->i_buffer = len;
  1504.             int canc = vlc_savecancel ();
  1505.             int val = srtp_send( id->srtp, out->p_buffer, &len, len + 10 );
  1506.             vlc_restorecancel (canc);
  1507.             if( val )
  1508.             {
  1509.                 errno = val;
  1510.                 msg_Dbg( id, "SRTP sending error: %m" );
  1511.                 block_Release( out );
  1512.                 out = NULL;
  1513.             }
  1514.             else
  1515.                 out->i_buffer = len;
  1516.         }
  1518.         if (out)
  1519.             mwait (out->i_dts + i_caching);
  1520.         vlc_cleanup_pop ();
  1521.         if (out == NULL)
  1522.             continue;
  1524.         ssize_t len = out->i_buffer;
  1525.         int canc = vlc_savecancel ();
  1527.         vlc_mutex_lock( &id->lock_sink );
  1528.         unsigned deadc = 0; /* How many dead sockets? */
  1529.         int deadv[id->sinkc]; /* Dead sockets list */
  1531.         for( int i = 0; i < id->sinkc; i++ )
  1532.         {
  1533.             if( !id->srtp ) /* FIXME: SRTCP support */
  1534.                 SendRTCP( id->sinkv[i].rtcp, out );
  1536.             if( send( id->sinkv[i].rtp_fd, out->p_buffer, len, 0 ) >= 0 )
  1537.                 continue;
  1538.             switch( net_errno )
  1539.             {
  1540.                 /* Soft errors (e.g. ICMP): */
  1541.                 case ECONNREFUSED: /* Port unreachable */
  1542.                 case ENOPROTOOPT:
  1543. #ifdef EPROTO
  1544.                 case EPROTO:       /* Protocol unreachable */
  1545. #endif
  1546.                 case EHOSTUNREACH: /* Host unreachable */
  1547.                 case ENETUNREACH:  /* Network unreachable */
  1548.                 case ENETDOWN:     /* Entire network down */
  1549.                     send( id->sinkv[i].rtp_fd, out->p_buffer, len, 0 );
  1550.                 /* Transient congestion: */
  1551.                 case ENOMEM: /* out of socket buffers */
  1552.                 case ENOBUFS:
  1553.                 case EAGAIN:
  1554. #if (EAGAIN != EWOULDBLOCK)
  1555.                 case EWOULDBLOCK:
  1556. #endif
  1557.                     continue;
  1558.             }
  1560.             deadv[deadc++] = id->sinkv[i].rtp_fd;
  1561.         }
  1562.         vlc_mutex_unlock( &id->lock_sink );
  1563.         block_Release( out );
  1565.         for( unsigned i = 0; i < deadc; i++ )
  1566.         {
  1567.             msg_Dbg( id, "removing socket %d", deadv[i] );
  1568.             rtp_del_sink( id, deadv[i] );
  1569.         }
  1571.         /* Hopefully we won't overflow the SO_MAXCONN accept queue */
  1572.         while( id->listen_fd != NULL )
  1573.         {
  1574.             int fd = net_Accept( id, id->listen_fd, 0 );
  1575.             if( fd == -1 )
  1576.                 break;
  1577.             msg_Dbg( id, "adding socket %d", fd );
  1578.             rtp_add_sink( id, fd, true );
  1579.         }
  1580.         vlc_restorecancel (canc);
  1581.     }
  1582.     return NULL;
  1583. }
  1585. int rtp_add_sink( sout_stream_id_t *id, int fd, bool rtcp_mux )
  1586. {
  1587.     rtp_sink_t sink = { fd, NULL };
  1588.     sink.rtcp = OpenRTCP( VLC_OBJECT( id->p_stream ), fd, IPPROTO_UDP,
  1589.                           rtcp_mux );
  1590.     if( sink.rtcp == NULL )
  1591.         msg_Err( id, "RTCP failed!" );
  1593.     vlc_mutex_lock( &id->lock_sink );
  1594.     INSERT_ELEM( id->sinkv, id->sinkc, id->sinkc, sink );
  1595.     vlc_mutex_unlock( &id->lock_sink );
  1596.     return VLC_SUCCESS;
  1597. }
  1599. void rtp_del_sink( sout_stream_id_t *id, int fd )
  1600. {
  1601.     rtp_sink_t sink = { fd, NULL };
  1603.     /* NOTE: must be safe to use if fd is not included */
  1604.     vlc_mutex_lock( &id->lock_sink );
  1605.     for( int i = 0; i < id->sinkc; i++ )
  1606.     {
  1607.         if (id->sinkv[i].rtp_fd == fd)
  1608.         {
  1609.             sink = id->sinkv[i];
  1610.             REMOVE_ELEM( id->sinkv, id->sinkc, i );
  1611.             break;
  1612.         }
  1613.     }
  1614.     vlc_mutex_unlock( &id->lock_sink );
  1616.     CloseRTCP( sink.rtcp );
  1617.     net_Close( sink.rtp_fd );
  1618. }
  1620. uint16_t rtp_get_seq( const sout_stream_id_t *id )
  1621. {
  1622.     /* This will return values for the next packet.
  1623.      * Accounting for caching would not be totally trivial. */
  1624.     return id->i_sequence;
  1625. }
  1627. uint32_t rtp_get_ts( const sout_stream_id_t *id )
  1628. {
  1629.     /* ... and this will return the value for the last packet.
  1630.      * Lame, but close enough. */
  1631.     return id->i_timestamp;
  1632. }
  1634. /* FIXME: this is pretty bad - if we remove and then insert an ES
  1635.  * the number will get unsynched from inside RTSP */
  1636. unsigned rtp_get_num( const sout_stream_id_t *id )
  1637. {
  1638.     sout_stream_sys_t *p_sys = id->p_stream->p_sys;
  1639.     int i;
  1641.     vlc_mutex_lock( &p_sys->lock_es );
  1642.     for( i = 0; i < p_sys->i_es; i++ )
  1643.     {
  1644.         if( id == p_sys->es[i] )
  1645.             break;
  1646.     }
  1647.     vlc_mutex_unlock( &p_sys->lock_es );
  1649.     return i;
  1650. }
  1653. void rtp_packetize_common( sout_stream_id_t *id, block_t *out,
  1654.                            int b_marker, int64_t i_pts )
  1655. {
  1656.     uint32_t i_timestamp = i_pts * (int64_t)id->i_clock_rate / INT64_C(1000000);
  1658.     out->p_buffer[0] = 0x80;
  1659.     out->p_buffer[1] = (b_marker?0x80:0x00)|id->i_payload_type;
  1660.     out->p_buffer[2] = ( id->i_sequence >> 8)&0xff;
  1661.     out->p_buffer[3] = ( id->i_sequence     )&0xff;
  1662.     out->p_buffer[4] = ( i_timestamp >> 24 )&0xff;
  1663.     out->p_buffer[5] = ( i_timestamp >> 16 )&0xff;
  1664.     out->p_buffer[6] = ( i_timestamp >>  8 )&0xff;
  1665.     out->p_buffer[7] = ( i_timestamp       )&0xff;
  1667.     memcpy( out->p_buffer + 8, id->ssrc, 4 );
  1669.     out->i_buffer = 12;
  1670.     id->i_timestamp = i_timestamp;
  1671.     id->i_sequence++;
  1672. }
  1674. void rtp_packetize_send( sout_stream_id_t *id, block_t *out )
  1675. {
  1676.     block_FifoPut( id->p_fifo, out );
  1677. }
  1679. /**
  1680.  * @return configured max RTP payload size (including payload type-specific
  1681.  * headers, excluding RTP and transport headers)
  1682.  */
  1683. size_t rtp_mtu (const sout_stream_id_t *id)
  1684. {
  1685.     return id->i_mtu - 12;
  1686. }
  1688. /*****************************************************************************
  1689.  * Non-RTP mux
  1690.  *****************************************************************************/
  1692. /** Add an ES to a non-RTP muxed stream */
  1693. static sout_stream_id_t *MuxAdd( sout_stream_t *p_stream, es_format_t *p_fmt )
  1694. {
  1695.     sout_input_t      *p_input;
  1696.     sout_mux_t *p_mux = p_stream->p_sys->p_mux;
  1697.     assert( p_mux != NULL );
  1699.     p_input = sout_MuxAddStream( p_mux, p_fmt );
  1700.     if( p_input == NULL )
  1701.     {
  1702.         msg_Err( p_stream, "cannot add this stream to the muxer" );
  1703.         return NULL;
  1704.     }
  1706.     return (sout_stream_id_t *)p_input;
  1707. }
  1710. static int MuxSend( sout_stream_t *p_stream, sout_stream_id_t *id,
  1711.                     block_t *p_buffer )
  1712. {
  1713.     sout_mux_t *p_mux = p_stream->p_sys->p_mux;
  1714.     assert( p_mux != NULL );
  1716.     sout_MuxSendBuffer( p_mux, (sout_input_t *)id, p_buffer );
  1717.     return VLC_SUCCESS;
  1718. }
  1721. /** Remove an ES from a non-RTP muxed stream */
  1722. static int MuxDel( sout_stream_t *p_stream, sout_stream_id_t *id )
  1723. {
  1724.     sout_mux_t *p_mux = p_stream->p_sys->p_mux;
  1725.     assert( p_mux != NULL );
  1727.     sout_MuxDeleteStream( p_mux, (sout_input_t *)id );
  1728.     return VLC_SUCCESS;
  1729. }
  1732. static ssize_t AccessOutGrabberWriteBuffer( sout_stream_t *p_stream,
  1733.                                             const block_t *p_buffer )
  1734. {
  1735.     sout_stream_sys_t *p_sys = p_stream->p_sys;
  1736.     sout_stream_id_t *id = p_sys->es[0];
  1738.     int64_t  i_dts = p_buffer->i_dts;
  1740.     uint8_t         *p_data = p_buffer->p_buffer;
  1741.     size_t          i_data  = p_buffer->i_buffer;
  1742.     size_t          i_max   = id->i_mtu - 12;
  1744.     size_t i_packet = ( p_buffer->i_buffer + i_max - 1 ) / i_max;
  1746.     while( i_data > 0 )
  1747.     {
  1748.         size_t i_size;
  1750.         /* output complete packet */
  1751.         if( p_sys->packet &&
  1752.             p_sys->packet->i_buffer + i_data > i_max )
  1753.         {
  1754.             rtp_packetize_send( id, p_sys->packet );
  1755.             p_sys->packet = NULL;
  1756.         }
  1758.         if( p_sys->packet == NULL )
  1759.         {
  1760.             /* allocate a new packet */
  1761.             p_sys->packet = block_New( p_stream, id->i_mtu );
  1762.             rtp_packetize_common( id, p_sys->packet, 1, i_dts );
  1763.             p_sys->packet->i_dts = i_dts;
  1764.             p_sys->packet->i_length = p_buffer->i_length / i_packet;
  1765.             i_dts += p_sys->packet->i_length;
  1766.         }
  1768.         i_size = __MIN( i_data,
  1769.                         (unsigned)(id->i_mtu - p_sys->packet->i_buffer) );
  1771.         memcpy( &p_sys->packet->p_buffer[p_sys->packet->i_buffer],
  1772.                 p_data, i_size );
  1774.         p_sys->packet->i_buffer += i_size;
  1775.         p_data += i_size;
  1776.         i_data -= i_size;
  1777.     }
  1779.     return VLC_SUCCESS;
  1780. }
  1783. static ssize_t AccessOutGrabberWrite( sout_access_out_t *p_access,
  1784.                                       block_t *p_buffer )
  1785. {
  1786.     sout_stream_t *p_stream = (sout_stream_t*)p_access->p_sys;
  1788.     while( p_buffer )
  1789.     {
  1790.         block_t *p_next;
  1792.         AccessOutGrabberWriteBuffer( p_stream, p_buffer );
  1794.         p_next = p_buffer->p_next;
  1795.         block_Release( p_buffer );
  1796.         p_buffer = p_next;
  1797.     }
  1799.     return VLC_SUCCESS;
  1800. }
  1803. static sout_access_out_t *GrabberCreate( sout_stream_t *p_stream )
  1804. {
  1805.     sout_access_out_t *p_grab;
  1807.     p_grab = vlc_object_create( p_stream->p_sout, sizeof( *p_grab ) );
  1808.     if( p_grab == NULL )
  1809.         return NULL;
  1811.     p_grab->p_module    = NULL;
  1812.     p_grab->psz_access  = strdup( "grab" );
  1813.     p_grab->p_cfg       = NULL;
  1814.     p_grab->psz_path    = strdup( "" );
  1815.     p_grab->p_sys       = (sout_access_out_sys_t *)p_stream;
  1816.     p_grab->pf_seek     = NULL;
  1817.     p_grab->pf_write    = AccessOutGrabberWrite;
  1818.     vlc_object_attach( p_grab, p_stream );
  1819.     return p_grab;
  1820. }