46fdb3c4cf142511f203231fb24d58fea2a9fc21
[vlc.git] / modules / stream_out / rtp.c
1 /*****************************************************************************
2  * rtp.c
3  *****************************************************************************
4  * Copyright (C) 2003 VideoLAN
5  * $Id: rtp.c,v 1.7 2003/11/21 15:32:08 fenrir Exp $
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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>
28
29 #include <vlc/vlc.h>
30 #include <vlc/input.h>
31 #include <vlc/sout.h>
32
33 #include "httpd.h"
34 #include "network.h"
35
36 /*****************************************************************************
37  * Module descriptor
38  *****************************************************************************/
39 static int  Open ( vlc_object_t * );
40 static void Close( vlc_object_t * );
41
42 vlc_module_begin();
43     set_description( _("RTP stream") );
44     set_capability( "sout stream", 0 );
45     add_shortcut( "rtp" );
46     set_callbacks( Open, Close );
47 vlc_module_end();
48
49 /*****************************************************************************
50  * Exported prototypes
51  *****************************************************************************/
52 static sout_stream_id_t *Add ( sout_stream_t *, es_format_t * );
53 static int               Del ( sout_stream_t *, sout_stream_id_t * );
54 static int               Send( sout_stream_t *, sout_stream_id_t *, sout_buffer_t* );
55
56
57 struct sout_stream_sys_t
58 {
59     /* sdp */
60     int64_t i_sdp_id;
61     int     i_sdp_version;
62     char    *psz_sdp;
63
64     vlc_mutex_t  lock_sdp;
65
66     httpd_t      *p_httpd;
67     httpd_host_t *p_httpd_host;
68     httpd_file_t *p_httpd_file;
69
70     /* */
71     char *psz_destination;
72     int  i_port;
73     int  i_ttl;
74
75     /* when need to use a private one or when using muxer */
76     int i_payload_type;
77
78     /* in case we do TS/PS over rtp */
79     sout_mux_t        *p_mux;
80     sout_access_out_t *p_access;
81     int               i_mtu;
82     sout_access_out_t *p_grab;
83     uint16_t          i_sequence;
84     uint32_t          i_timestamp_start;
85     uint8_t           ssrc[4];
86     sout_buffer_t     *packet;
87
88     /* */
89     int              i_es;
90     sout_stream_id_t **es;
91 };
92
93 typedef int (*pf_rtp_packetizer_t)( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
94 struct sout_stream_id_t
95 {
96     /* rtp field */
97     uint8_t     i_payload_type;
98     uint16_t    i_sequence;
99     uint32_t    i_timestamp_start;
100     uint8_t     ssrc[4];
101
102     /* for sdp */
103     int         i_clock_rate;
104     char        *psz_rtpmap;
105     char        *psz_fmtp;
106     char        *psz_destination;
107     int         i_port;
108     int         i_cat;
109
110     /* Packetizer specific fields */
111     pf_rtp_packetizer_t pf_packetize;
112     int           i_mtu;
113
114     /* for sending the packets */
115     sout_access_out_t *p_access;
116     sout_input_t      *p_input;
117 };
118 static int AccessOutGrabberWrite( sout_access_out_t *, sout_buffer_t * );
119
120 static int  HttpCallback( httpd_file_callback_args_t *p_args,
121                           uint8_t *p_request, int i_request,
122                           uint8_t **pp_data, int *pi_data );
123
124 /*****************************************************************************
125  * Open:
126  *****************************************************************************/
127 static int Open( vlc_object_t *p_this )
128 {
129     sout_stream_t       *p_stream = (sout_stream_t*)p_this;
130     sout_instance_t     *p_sout = p_stream->p_sout;
131     sout_stream_sys_t   *p_sys;
132
133     char *val;
134
135     p_sys = malloc( sizeof( sout_stream_sys_t ) );
136     p_sys->psz_destination = sout_cfg_find_value( p_stream->p_cfg, "dst" );
137     if( ( val = sout_cfg_find_value( p_stream->p_cfg, "port" ) ) )
138     {
139         p_sys->i_port = atoi( val );
140     }
141     if( !p_sys->psz_destination || *p_sys->psz_destination == '\0' || p_sys->i_port <= 0 )
142     {
143         msg_Err( p_stream, "invalid/missing dst or port" );
144         free( p_sys );
145         return VLC_EGENERIC;
146     }
147     if( ( val = sout_cfg_find_value( p_stream->p_cfg, "ttl" ) ) )
148     {
149         p_sys->i_ttl = atoi( val );
150     }
151     else
152     {
153         p_sys->i_ttl = config_GetInt( p_stream, "ttl" );
154     }
155
156     p_sys->i_payload_type = 96;
157     p_sys->i_es = 0;
158     p_sys->es   = NULL;
159     p_sys->psz_sdp = NULL;
160
161     p_sys->i_sdp_id = mdate();
162     p_sys->i_sdp_version = 1;
163     p_sys->psz_sdp = NULL;
164     p_sys->p_httpd = NULL;
165     p_sys->p_httpd_host = NULL;
166     p_sys->p_httpd_file = NULL;
167
168     if( ( val = sout_cfg_find_value( p_stream->p_cfg, "mux" ) ) )
169     {
170         sout_access_out_t *p_grab;
171
172         char *psz_rtpmap;
173         char access[100];
174         char url[strlen( p_sys->psz_destination ) + 1 + 12 + 1];
175
176         /* Check muxer type */
177         if( !strncasecmp( val, "ps", 2 ) || !strncasecmp( val, "mpeg1", 5 ) )
178         {
179             psz_rtpmap = "MP2P/90000";
180         }
181         else if( !strncasecmp( val, "ts", 2 ) )
182         {
183             psz_rtpmap = "MP2T/90000";
184             p_sys->i_payload_type = 33;
185         }
186         else
187         {
188             msg_Err( p_stream, "unsupported muxer type with rtp (only ts/ps)" );
189             return VLC_EGENERIC;
190         }
191
192         /* create the access out */
193         if( p_sys->i_ttl > 0 )
194         {
195             sprintf( access, "udp{raw,ttl=%d}", p_sys->i_ttl );
196         }
197         else
198         {
199             sprintf( access, "udp{raw}" );
200         }
201         sprintf( url, "%s:%d", p_sys->psz_destination, p_sys->i_port );
202         if( ( p_sys->p_access = sout_AccessOutNew( p_sout, access, url ) ) == NULL )
203         {
204             msg_Err( p_stream, "cannot create the access out for %s://%s",
205                      access, url );
206             free( p_sys );
207             return VLC_EGENERIC;
208         }
209         p_sys->i_mtu = config_GetInt( p_stream, "mtu" );  /* XXX beurk */
210         if( p_sys->i_mtu <= 16 )
211         {
212             /* better than nothing */
213             p_sys->i_mtu = 1500;
214         }
215
216         /* the access out grabber TODO export it as sout_AccessOutGrabberNew */
217         p_grab = p_sys->p_grab = vlc_object_create( p_sout, sizeof( sout_access_out_t ) );
218         p_grab->p_module    = NULL;
219         p_grab->p_sout      = p_sout;
220         p_grab->psz_access  = strdup( "grab" );
221         p_grab->p_cfg       = NULL;
222         p_grab->psz_name    = strdup( "" );
223         p_grab->p_sys       = (sout_access_out_sys_t*)p_stream;
224         p_grab->pf_seek     = NULL;
225         p_grab->pf_write    = AccessOutGrabberWrite;
226
227         /* the muxer */
228         if( ( p_sys->p_mux = sout_MuxNew( p_sout, val, p_sys->p_grab ) ) == NULL )
229         {
230             msg_Err( p_stream, "cannot create the muxer (%s)", val );
231             sout_AccessOutDelete( p_sys->p_grab );
232             sout_AccessOutDelete( p_sys->p_access );
233             free( p_sys );
234             return VLC_EGENERIC;
235         }
236         p_sout->i_preheader = __MAX( p_sout->i_preheader, p_sys->p_mux->i_preheader );
237
238         /* create the SDP only once */
239         p_sys->psz_sdp = malloc( 200 + 20 + 10 + strlen( p_sys->psz_destination ) + 10 + 10 + 10 + 10 + strlen( psz_rtpmap ) );
240         sprintf( p_sys->psz_sdp,
241                  "v=0\n"
242                  "o=- "I64Fd" %d IN IP4 127.0.0.1\n"
243                  "s=NONE\n"
244                  "c=IN IP4 %s/%d\n"
245                  "m=video %d RTP/AVP %d\n"
246                  "a=rtpmap:%d %s\n",
247                  p_sys->i_sdp_id, p_sys->i_sdp_version,
248                  p_sys->psz_destination, p_sys->i_ttl,
249                  p_sys->i_port, p_sys->i_payload_type,
250                  p_sys->i_payload_type, psz_rtpmap );
251
252         fprintf( stderr, "sdp=%s", p_sys->psz_sdp );
253
254         /* create the rtp context */
255         p_sys->ssrc[0] = rand()&0xff;
256         p_sys->ssrc[1] = rand()&0xff;
257         p_sys->ssrc[2] = rand()&0xff;
258         p_sys->ssrc[3] = rand()&0xff;
259         p_sys->i_sequence = rand()&0xffff;
260         p_sys->i_timestamp_start = rand()&0xffffffff;
261         p_sys->packet = NULL;
262     }
263     else
264     {
265         p_sys->p_mux    = NULL;
266         p_sys->p_access = NULL;
267         p_sys->p_grab   = NULL;
268     }
269
270     if( ( val = sout_cfg_find_value( p_stream->p_cfg, "sdp" ) ) )
271     {
272         vlc_url_t url;
273
274         vlc_UrlParse( &url, val, 0 );
275         if( url.psz_protocol && !strcmp( url.psz_protocol, "http" ) )
276         {
277             if( ( p_sys->p_httpd = httpd_Find( VLC_OBJECT(p_stream), VLC_TRUE ) ) )
278             {
279                 p_sys->p_httpd_host = p_sys->p_httpd->pf_register_host( p_sys->p_httpd,
280                                                                         url.psz_host,
281                                                                         url.i_port );
282                 if( p_sys->p_httpd_host )
283                 {
284                     p_sys->p_httpd_file =
285                         p_sys->p_httpd->pf_register_file( p_sys->p_httpd,
286                                                           url.psz_path ? url.psz_path : "/",
287                                                           "application/sdp",
288                                                           NULL, NULL,
289                                                           HttpCallback, HttpCallback,
290                                                           (void*)p_sys );
291                 }
292             }
293             if( p_sys->p_httpd_file == NULL )
294             {
295                 msg_Err( p_stream, "cannot export sdp as http" );
296             }
297         }
298         else
299         {
300             msg_Warn( p_stream, "unknow protocol for SDP (%s)", url.psz_protocol );
301         }
302         vlc_UrlClean( &url );
303     }
304
305     vlc_mutex_init( p_stream, &p_sys->lock_sdp );
306
307     p_stream->pf_add    = Add;
308     p_stream->pf_del    = Del;
309     p_stream->pf_send   = Send;
310
311     p_stream->p_sys     = p_sys;
312
313     return VLC_SUCCESS;
314 }
315
316 /*****************************************************************************
317  * Close:
318  *****************************************************************************/
319 static void Close( vlc_object_t * p_this )
320 {
321     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
322     sout_stream_sys_t *p_sys = p_stream->p_sys;
323
324     if( p_sys->p_mux )
325     {
326         sout_MuxDelete( p_sys->p_mux );
327         sout_AccessOutDelete( p_sys->p_access );
328         sout_AccessOutDelete( p_sys->p_grab );
329         if( p_sys->packet )
330         {
331             sout_BufferDelete( p_stream->p_sout, p_sys->packet );
332         }
333     }
334
335     vlc_mutex_destroy( &p_sys->lock_sdp );
336
337     if( p_sys->p_httpd_file )
338     {
339         p_sys->p_httpd->pf_unregister_file( p_sys->p_httpd, p_sys->p_httpd_file );
340     }
341     if( p_sys->p_httpd_host )
342     {
343         p_sys->p_httpd->pf_unregister_host( p_sys->p_httpd, p_sys->p_httpd_host );
344     }
345     if( p_sys->p_httpd )
346     {
347         httpd_Release( p_sys->p_httpd );
348     }
349
350     if( p_sys->psz_sdp )
351     {
352         free( p_sys->psz_sdp );
353     }
354     free( p_sys );
355 }
356
357
358 /*****************************************************************************
359  * SDPGenerate
360  *****************************************************************************/
361 static void SDPGenerate( sout_stream_t *p_stream )
362 {
363     sout_stream_sys_t *p_sys = p_stream->p_sys;
364     int i_size;
365     char *psz_sdp, *p;
366     int i;
367
368     i_size = strlen( "v=0\n" ) +
369              strlen( "o=- * * IN IP4 127.0.0.1\n" ) +
370              strlen( "s=NONE\n" ) +
371              strlen( "c=IN IP4 */*\n" ) +
372              strlen( p_sys->psz_destination ) +
373              20 + 10 + 10 + 1;
374     for( i = 0; i < p_sys->i_es; i++ )
375     {
376         sout_stream_id_t *id = p_sys->es[i];
377
378         i_size += strlen( "m=**d*o * RTP/AVP *\n" ) + 10 + 10;
379
380         if( id->psz_rtpmap )
381         {
382             i_size += strlen( "a=rtpmap:* *\n" ) + strlen( id->psz_rtpmap )+10;
383         }
384         if( id->psz_fmtp )
385         {
386             i_size += strlen( "a=fmtp:* *\n" ) + strlen( id->psz_fmtp ) + 10;
387         }
388     }
389
390     p = psz_sdp = malloc( i_size );
391     p += sprintf( p, "v=0\n" );
392     p += sprintf( p, "o=- "I64Fd" %d IN IP4 127.0.0.1\n", p_sys->i_sdp_id, p_sys->i_sdp_version );
393     p += sprintf( p, "s=NONE\n" );
394     p += sprintf( p, "c=IN IP4 %s/%d\n", p_sys->psz_destination, p_sys->i_ttl );
395
396     for( i = 0; i < p_sys->i_es; i++ )
397     {
398         sout_stream_id_t *id = p_sys->es[i];
399
400         if( id->i_cat == AUDIO_ES )
401         {
402             p += sprintf( p, "m=audio %d RTP/AVP %d\n",
403                           id->i_port, id->i_payload_type );
404         }
405         else if( id->i_cat == VIDEO_ES )
406         {
407             p += sprintf( p, "m=video %d RTP/AVP %d\n",
408                           id->i_port, id->i_payload_type );
409         }
410         else
411         {
412             continue;
413         }
414         if( id->psz_rtpmap )
415         {
416             p += sprintf( p, "a=rtpmap:%d %s\n", id->i_payload_type, id->psz_rtpmap );
417         }
418         if( id->psz_fmtp )
419         {
420             p += sprintf( p, "a=fmtp:%d %s\n", id->i_payload_type, id->psz_fmtp );
421         }
422     }
423
424     vlc_mutex_lock( &p_sys->lock_sdp );
425     free( p_sys->psz_sdp );
426     p_sys->psz_sdp = psz_sdp;
427     vlc_mutex_unlock( &p_sys->lock_sdp );
428
429     p_sys->i_sdp_version++;
430
431     fprintf( stderr, "sdp=%s", p_sys->psz_sdp );
432 }
433
434 /*****************************************************************************
435  *
436  *****************************************************************************/
437
438 static int rtp_packetize_l16  ( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
439 static int rtp_packetize_l8   ( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
440 static int rtp_packetize_mpa  ( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
441 static int rtp_packetize_mpv  ( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
442 static int rtp_packetize_ac3  ( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
443 static int rtp_packetize_split( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
444 static int rtp_packetize_mp4a ( sout_stream_t *, sout_stream_id_t *, sout_buffer_t * );
445
446 static void sprintf_hexa( char *s, uint8_t *p_data, int i_data )
447 {
448     static const char hex[16] = "0123456789ABCDEF";
449     int i;
450
451     for( i = 0; i < i_data; i++ )
452     {
453         s[2*i+0] = hex[(p_data[i]>>8)&0xf];
454         s[2*i+1] = hex[(p_data[i]   )&0xf];
455     }
456     s[2*i_data] = '\0';
457 }
458
459 static sout_stream_id_t * Add      ( sout_stream_t *p_stream, es_format_t *p_fmt )
460 {
461     sout_instance_t   *p_sout = p_stream->p_sout;
462     sout_stream_sys_t *p_sys = p_stream->p_sys;
463     sout_stream_id_t  *id;
464     sout_access_out_t *p_access = NULL;
465
466     char access[100];
467     char url[strlen( p_sys->psz_destination ) + 1 + 12 + 1];
468
469     if( p_sys->p_mux != NULL )
470     {
471         sout_input_t      *p_input  = NULL;
472         if( ( p_input = sout_MuxAddStream( p_sys->p_mux, p_fmt ) ) == NULL )
473         {
474             msg_Err( p_stream, "cannot add this stream to the muxer" );
475             return NULL;
476         }
477
478         id = malloc( sizeof( sout_stream_id_t ) );
479         id->p_access    = NULL;
480         id->p_input     = p_input;
481         id->pf_packetize= NULL;
482
483         return id;
484     }
485
486     /* first try to create the access out */
487     if( p_sys->i_ttl > 0 )
488     {
489         sprintf( access, "udp{raw,ttl=%d}", p_sys->i_ttl );
490     }
491     else
492     {
493         sprintf( access, "udp{raw}" );
494     }
495     sprintf( url, "%s:%d", p_sys->psz_destination, p_sys->i_port );
496     if( ( p_access = sout_AccessOutNew( p_sout, access, url ) ) == NULL )
497     {
498         msg_Err( p_stream, "cannot create the access out for %s://%s",
499                  access, url );
500         return NULL;
501     }
502
503     /* not create the rtp specific stuff */
504     id = malloc( sizeof( sout_stream_id_t ) );
505     id->p_access   = p_access;
506     id->p_input    = NULL;
507     id->psz_rtpmap = NULL;
508     id->psz_fmtp   = NULL;
509     id->psz_destination = strdup( p_sys->psz_destination );
510     id->i_port = p_sys->i_port;
511
512     switch( p_fmt->i_codec )
513     {
514         case VLC_FOURCC( 's', '1', '6', 'b' ):
515             if( p_fmt->audio.i_channels == 1 && p_fmt->audio.i_rate == 44100 )
516             {
517                 id->i_payload_type = 11;
518             }
519             else if( p_fmt->audio.i_channels == 2 && p_fmt->audio.i_rate == 44100 )
520             {
521                 id->i_payload_type = 10;
522             }
523             else
524             {
525                 id->i_payload_type = p_sys->i_payload_type++;
526             }
527             id->psz_rtpmap = malloc( strlen( "L16/*/*" ) + 20+1 );
528             sprintf( id->psz_rtpmap, "L16/%d/%d", p_fmt->audio.i_rate, p_fmt->audio.i_channels );
529             id->i_clock_rate = p_fmt->audio.i_rate;
530             id->pf_packetize = rtp_packetize_l16;
531             break;
532         case VLC_FOURCC( 'u', '8', ' ', ' ' ):
533             id->i_payload_type = p_sys->i_payload_type++;
534             id->psz_rtpmap = malloc( strlen( "L8/*/*" ) + 20+1 );
535             sprintf( id->psz_rtpmap, "L8/%d/%d", p_fmt->audio.i_rate, p_fmt->audio.i_channels );
536             id->i_clock_rate = p_fmt->audio.i_rate;
537             id->pf_packetize = rtp_packetize_l8;
538             break;
539         case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
540             id->i_payload_type = 14;
541             id->i_clock_rate = 90000;
542             id->psz_rtpmap = strdup( "MPA/90000" );
543             id->pf_packetize = rtp_packetize_mpa;
544             break;
545         case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
546             id->i_payload_type = 32;
547             id->i_clock_rate = 90000;
548             id->psz_rtpmap = strdup( "MPV/90000" );
549             id->pf_packetize = rtp_packetize_mpv;
550             break;
551         case VLC_FOURCC( 'a', '5', '2', ' ' ):
552             id->i_payload_type = p_sys->i_payload_type++;
553             id->i_clock_rate = 90000;
554             id->psz_rtpmap = strdup( "ac3/90000" );
555             id->pf_packetize = rtp_packetize_ac3;
556             break;
557         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
558         {
559             char hexa[2*p_fmt->i_extra +1];
560
561             id->i_payload_type = p_sys->i_payload_type++;
562             id->i_clock_rate = 90000;
563             id->psz_rtpmap = strdup( "MP4V-ES/90000" );
564             id->pf_packetize = rtp_packetize_split;
565             if( p_fmt->i_extra > 0 )
566             {
567                 id->psz_fmtp = malloc( 100 + 2 * p_fmt->i_extra );
568                 sprintf_hexa( hexa, p_fmt->p_extra, p_fmt->i_extra );
569                 sprintf( id->psz_fmtp,
570                          "profile-level-id=3; config=%s", hexa );
571             }
572             break;
573         }
574         case VLC_FOURCC( 'm', 'p', '4', 'a' ):
575         {
576             char hexa[2*p_fmt->i_extra +1];
577
578             id->i_payload_type = p_sys->i_payload_type++;
579             id->i_clock_rate = p_fmt->audio.i_rate;
580             id->psz_rtpmap = malloc( strlen( "mpeg4-generic/" ) + 12 );
581             sprintf( id->psz_rtpmap, "mpeg4-generic/%d", p_fmt->audio.i_rate );
582             id->pf_packetize = rtp_packetize_mp4a;
583             id->psz_fmtp = malloc( 200 + 2 * p_fmt->i_extra );
584             sprintf_hexa( hexa, p_fmt->p_extra, p_fmt->i_extra );
585             sprintf( id->psz_fmtp,
586                      "streamtype=5; profile-level-id=15; mode=AAC-hbr; config=%s; "
587                      "SizeLength=13; IndexLength=3; IndexDeltaLength=3; Profile=1;", hexa );
588             break;
589         }
590
591         default:
592             msg_Err( p_stream, "cannot add this stream (unsupported codec:%4.4s)", (char*)&p_fmt->i_codec );
593             free( id );
594             return NULL;
595     }
596     id->i_cat = p_fmt->i_cat;
597
598     id->ssrc[0] = rand()&0xff;
599     id->ssrc[1] = rand()&0xff;
600     id->ssrc[2] = rand()&0xff;
601     id->ssrc[3] = rand()&0xff;
602     id->i_sequence = rand()&0xffff;
603     id->i_timestamp_start = rand()&0xffffffff;
604
605     id->i_mtu    = config_GetInt( p_stream, "mtu" );  /* XXX beuk */
606     if( id->i_mtu <= 16 )
607     {
608         /* better than nothing */
609         id->i_mtu = 1500;
610     }
611
612     msg_Dbg( p_stream, "access out %s:%s mtu=%d", access, url, id->i_mtu );
613
614     /* Update p_sys context */
615     /* update port used (2 -> 1 rtp, 1 rtcp )*/
616     TAB_APPEND( p_sys->i_es, p_sys->es, id );
617     if( p_sys->p_mux == NULL )
618     {
619         p_sys->i_port += 2;
620         SDPGenerate( p_stream );
621     }
622
623     return id;
624 }
625
626 static int     Del      ( sout_stream_t *p_stream, sout_stream_id_t *id )
627 {
628     sout_stream_sys_t *p_sys = p_stream->p_sys;
629
630     TAB_REMOVE( p_sys->i_es, p_sys->es, id );
631
632     if( id->p_access )
633     {
634         if( id->psz_rtpmap )
635         {
636             free( id->psz_rtpmap );
637         }
638         if( id->psz_fmtp )
639         {
640             free( id->psz_fmtp );
641         }
642         free( id->psz_destination );
643         sout_AccessOutDelete( id->p_access );
644     }
645     else if( id->p_input )
646     {
647         sout_MuxDeleteStream( p_sys->p_mux, id->p_input );
648     }
649     free( id );
650     return VLC_SUCCESS;
651 }
652
653 static int     Send     ( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *p_buffer )
654 {
655     sout_buffer_t *p_next;
656
657     if( p_stream->p_sys->p_mux )
658     {
659         sout_MuxSendBuffer( p_stream->p_sys->p_mux, id->p_input, p_buffer );
660     }
661     else
662     {
663         while( p_buffer )
664         {
665             p_next = p_buffer->p_next;
666             if( id->pf_packetize( p_stream, id, p_buffer ) )
667             {
668                 break;
669             }
670             sout_BufferDelete( p_stream->p_sout, p_buffer );
671             p_buffer = p_next;
672         }
673     }
674     return VLC_SUCCESS;
675 }
676
677 static int  HttpCallback( httpd_file_callback_args_t *p_args,
678                           uint8_t *p_request, int i_request,
679                           uint8_t **pp_data, int *pi_data )
680 {
681     sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_args;
682     vlc_mutex_lock( &p_sys->lock_sdp );
683     if( p_sys->psz_sdp && *p_sys->psz_sdp )
684     {
685         *pi_data = strlen( p_sys->psz_sdp );
686         *pp_data = malloc( *pi_data );
687         memcpy( *pp_data, p_sys->psz_sdp, *pi_data );
688     }
689     else
690     {
691         *pp_data = NULL;
692         *pi_data = 0;
693     }
694     vlc_mutex_unlock( &p_sys->lock_sdp );
695
696     return VLC_SUCCESS;
697 }
698
699 static int AccessOutGrabberWriteBuffer( sout_stream_t *p_stream, sout_buffer_t *p_buffer )
700 {
701     sout_stream_sys_t *p_sys = p_stream->p_sys;
702
703     int64_t  i_dts = p_buffer->i_dts;
704     uint32_t i_timestamp = i_dts * 9 / 100;
705
706     uint8_t         *p_data = p_buffer->p_buffer;
707     unsigned int    i_data  = p_buffer->i_size;
708     unsigned int    i_max   = p_sys->i_mtu - 12;
709
710     int      i_packet = ( p_buffer->i_size + i_max - 1 ) / i_max;
711
712     while( i_data > 0 )
713     {
714         unsigned int i_size;
715
716         /* output complete packet */
717         if( p_sys->packet &&
718             p_sys->packet->i_size + i_data > i_max )
719         {
720             sout_AccessOutWrite( p_sys->p_access, p_sys->packet );
721             p_sys->packet = NULL;
722         }
723
724         if( p_sys->packet == NULL )
725         {
726             /* allocate a new packet */
727             p_sys->packet = sout_BufferNew( p_stream->p_sout, p_sys->i_mtu );
728             p_sys->packet->p_buffer[ 0] = 0x80;
729             p_sys->packet->p_buffer[ 1] = p_sys->i_payload_type;
730             p_sys->packet->p_buffer[ 2] = ( p_sys->i_sequence >> 8)&0xff;
731             p_sys->packet->p_buffer[ 3] = ( p_sys->i_sequence     )&0xff;
732             p_sys->packet->p_buffer[ 4] = ( i_timestamp >> 24 )&0xff;
733             p_sys->packet->p_buffer[ 5] = ( i_timestamp >> 16 )&0xff;
734             p_sys->packet->p_buffer[ 6] = ( i_timestamp >>  8 )&0xff;
735             p_sys->packet->p_buffer[ 7] = ( i_timestamp       )&0xff;
736             p_sys->packet->p_buffer[ 8] = p_sys->ssrc[0];
737             p_sys->packet->p_buffer[ 9] = p_sys->ssrc[1];
738             p_sys->packet->p_buffer[10] = p_sys->ssrc[2];
739             p_sys->packet->p_buffer[11] = p_sys->ssrc[3];
740             p_sys->packet->i_size = 12;
741
742             p_sys->packet->i_dts = i_dts;
743             p_sys->packet->i_length = p_buffer->i_length / i_packet;
744             i_dts += p_sys->packet->i_length;
745
746             p_sys->i_sequence++;
747         }
748
749         i_size = __MIN( i_data, p_sys->i_mtu - p_sys->packet->i_size );
750
751         memcpy( &p_sys->packet->p_buffer[p_sys->packet->i_size],
752                 p_data,
753                 i_size );
754
755         p_sys->packet->i_size += i_size;
756         p_data += i_size;
757         i_data -= i_size;
758     }
759
760     return VLC_SUCCESS;
761 }
762
763 static int AccessOutGrabberWrite( sout_access_out_t *p_access, sout_buffer_t *p_buffer )
764 {
765     sout_stream_t *p_stream = (sout_stream_t*)p_access->p_sys;
766
767     //fprintf( stderr, "received buffer size=%d\n", p_buffer->i_size );
768     //
769     while( p_buffer )
770     {
771         sout_buffer_t *p_next;
772
773         AccessOutGrabberWriteBuffer( p_stream, p_buffer );
774
775         p_next = p_buffer->p_next;
776         sout_BufferDelete( p_access->p_sout, p_buffer );
777         p_buffer = p_next;
778     }
779
780     return VLC_SUCCESS;
781 }
782
783
784 static void rtp_packetize_common( sout_stream_id_t *id, sout_buffer_t *out, int b_marker, int64_t i_pts )
785 {
786     uint32_t i_timestamp = i_pts * (int64_t)id->i_clock_rate / (int64_t)1000000;
787
788     out->p_buffer[0] = 0x80;
789     out->p_buffer[1] = (b_marker?0x80:0x00)|id->i_payload_type;
790     out->p_buffer[2] = ( id->i_sequence >> 8)&0xff;
791     out->p_buffer[3] = ( id->i_sequence     )&0xff;
792     out->p_buffer[4] = ( i_timestamp >> 24 )&0xff;
793     out->p_buffer[5] = ( i_timestamp >> 16 )&0xff;
794     out->p_buffer[6] = ( i_timestamp >>  8 )&0xff;
795     out->p_buffer[7] = ( i_timestamp       )&0xff;
796
797     out->p_buffer[ 8] = id->ssrc[0];
798     out->p_buffer[ 9] = id->ssrc[1];
799     out->p_buffer[10] = id->ssrc[2];
800     out->p_buffer[11] = id->ssrc[3];
801
802     out->i_size = 12;
803     id->i_sequence++;
804 }
805
806 static int rtp_packetize_mpa( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *in )
807 {
808     int     i_max   = id->i_mtu - 12 - 4; /* payload max in one packet */
809     int     i_count = ( in->i_size + i_max - 1 ) / i_max;
810
811     uint8_t *p_data = in->p_buffer;
812     int     i_data  = in->i_size;
813     int     i;
814
815     for( i = 0; i < i_count; i++ )
816     {
817         int           i_payload = __MIN( i_max, i_data );
818         sout_buffer_t *out = sout_BufferNew( p_stream->p_sout, 16 + i_payload );
819
820         /* rtp common header */
821         rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
822         /* mbz set to 0 */
823         out->p_buffer[12] = 0;
824         out->p_buffer[13] = 0;
825         /* fragment offset in the current frame */
826         out->p_buffer[14] = ( (i*i_max) >> 8 )&0xff;
827         out->p_buffer[15] = ( (i*i_max)      )&0xff;
828         memcpy( &out->p_buffer[16], p_data, i_payload );
829
830         out->i_size   = 16 + i_payload;
831         out->i_dts    = in->i_dts + i * in->i_length / i_count;
832         out->i_length = in->i_length / i_count;
833
834         sout_AccessOutWrite( id->p_access, out );
835
836         p_data += i_payload;
837         i_data -= i_payload;
838     }
839
840     return VLC_SUCCESS;
841 }
842
843 /* rfc2250 */
844 static int rtp_packetize_mpv( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *in )
845 {
846     int     i_max   = id->i_mtu - 12 - 4; /* payload max in one packet */
847     int     i_count = ( in->i_size + i_max - 1 ) / i_max;
848
849     uint8_t *p_data = in->p_buffer;
850     int     i_data  = in->i_size;
851     int     i;
852     int     b_sequence_start = 0;
853     int     i_temporal_ref = 0;
854     int     i_picture_coding_type = 0;
855     int     i_fbv = 0, i_bfc = 0, i_ffv = 0, i_ffc = 0;
856     int     b_start_slice = 0;
857
858     /* preparse this packet to get some info */
859     if( in->i_size > 4 )
860     {
861         uint8_t *p = p_data;
862         int      i_rest = in->i_size;
863
864         for( ;; )
865         {
866             while( i_rest > 4 &&
867                    ( p[0] != 0x00 || p[1] != 0x00 || p[2] != 0x01 ) )
868             {
869                 p++;
870                 i_rest--;
871             }
872             if( i_rest <= 4 )
873             {
874                 break;
875             }
876             p += 3;
877             i_rest -= 4;
878
879             if( *p == 0xb3 )
880             {
881                 /* sequence start code */
882                 b_sequence_start = 1;
883             }
884             else if( *p == 0x00 && i_rest >= 4 )
885             {
886                 /* picture */
887                 i_temporal_ref = ( p[1] << 2) |((p[2]>>6)&0x03);
888                 i_picture_coding_type = (p[2] >> 3)&0x07;
889
890                 if( i_rest > 4 && ( i_picture_coding_type == 2 || i_picture_coding_type == 3 ) )
891                 {
892                     i_ffc = (p[3] >> 2)&0x01;
893                     i_bfc = ((p[3]&0x03) << 1)|((p[4]>>7)&0x01);
894                     if( i_picture_coding_type == 3 )
895                     {
896                         i_fbv = (p[4]>>6)&0x01;
897                         i_bfc = (p[4]>>3)&0x07;
898                     }
899                 }
900             }
901             else if( *p <= 0xaf )
902             {
903                 b_start_slice = 1;
904             }
905         }
906     }
907
908     for( i = 0; i < i_count; i++ )
909     {
910         int           i_payload = __MIN( i_max, i_data );
911         sout_buffer_t *out = sout_BufferNew( p_stream->p_sout, 16 + i_payload );
912         uint32_t      h = ( i_temporal_ref << 16 )|
913                           ( b_sequence_start << 13 )|
914                           ( b_start_slice << 12 )|
915                           ( i == i_count - 1 ? 1 << 11 : 0 )|
916                           ( i_picture_coding_type << 8 )|
917                           ( i_fbv << 7 )|( i_bfc << 4 )|( i_ffv << 3 )|i_ffc;
918
919         /* rtp common header */
920         rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
921
922         /* MBZ:5 T:1 TR:10 AN:1 N:1 S:1 B:1 E:1 P:3 FBV:1 BFC:3 FFV:1 FFC:3 */
923         out->p_buffer[12] = ( h >> 24 )&0xff;
924         out->p_buffer[13] = ( h >> 16 )&0xff;
925         out->p_buffer[14] = ( h >>  8 )&0xff;
926         out->p_buffer[15] = ( h       )&0xff;
927
928         memcpy( &out->p_buffer[16], p_data, i_payload );
929
930         out->i_size   = 16 + i_payload;
931         out->i_dts    = in->i_dts + i * in->i_length / i_count;
932         out->i_length = in->i_length / i_count;
933
934         sout_AccessOutWrite( id->p_access, out );
935
936         p_data += i_payload;
937         i_data -= i_payload;
938     }
939
940     return VLC_SUCCESS;
941 }
942 static int rtp_packetize_ac3( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *in )
943 {
944     int     i_max   = id->i_mtu - 12 - 2; /* payload max in one packet */
945     int     i_count = ( in->i_size + i_max - 1 ) / i_max;
946
947     uint8_t *p_data = in->p_buffer;
948     int     i_data  = in->i_size;
949     int     i;
950
951     for( i = 0; i < i_count; i++ )
952     {
953         int           i_payload = __MIN( i_max, i_data );
954         sout_buffer_t *out = sout_BufferNew( p_stream->p_sout, 14 + i_payload );
955
956         /* rtp common header */
957         rtp_packetize_common( id, out, (i == i_count - 1)?1:0, in->i_pts );
958         /* unit count */
959         out->p_buffer[12] = 1;
960         /* unit header */
961         out->p_buffer[13] = 0x00;
962         /* data */
963         memcpy( &out->p_buffer[14], p_data, i_payload );
964
965         out->i_size   = 14 + i_payload;
966         out->i_dts    = in->i_dts + i * in->i_length / i_count;
967         out->i_length = in->i_length / i_count;
968
969         sout_AccessOutWrite( id->p_access, out );
970
971         p_data += i_payload;
972         i_data -= i_payload;
973     }
974
975     return VLC_SUCCESS;
976 }
977
978 static int rtp_packetize_split( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *in )
979 {
980     int     i_max   = id->i_mtu - 12; /* payload max in one packet */
981     int     i_count = ( in->i_size + i_max - 1 ) / i_max;
982
983     uint8_t *p_data = in->p_buffer;
984     int     i_data  = in->i_size;
985     int     i;
986
987     for( i = 0; i < i_count; i++ )
988     {
989         int           i_payload = __MIN( i_max, i_data );
990         sout_buffer_t *out = sout_BufferNew( p_stream->p_sout, 12 + i_payload );
991
992         /* rtp common header */
993         rtp_packetize_common( id, out, ((i == i_count - 1)?1:0), (in->i_pts > 0 ? in->i_pts : in->i_dts) );
994         memcpy( &out->p_buffer[12], p_data, i_payload );
995
996         out->i_size   = 12 + i_payload;
997         out->i_dts    = in->i_dts + i * in->i_length / i_count;
998         out->i_length = in->i_length / i_count;
999
1000         sout_AccessOutWrite( id->p_access, out );
1001
1002         p_data += i_payload;
1003         i_data -= i_payload;
1004     }
1005
1006     return VLC_SUCCESS;
1007 }
1008
1009 static int rtp_packetize_l16( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *in )
1010 {
1011     int     i_max   = id->i_mtu - 12; /* payload max in one packet */
1012     int     i_count = ( in->i_size + i_max - 1 ) / i_max;
1013
1014     uint8_t *p_data = in->p_buffer;
1015     int     i_data  = in->i_size;
1016     int     i_packet = 0;
1017
1018     while( i_data > 0 )
1019     {
1020         int           i_payload = (__MIN( i_max, i_data )/4)*4;
1021         sout_buffer_t *out = sout_BufferNew( p_stream->p_sout, 12 + i_payload );
1022
1023         /* rtp common header */
1024         rtp_packetize_common( id, out, 0, (in->i_pts > 0 ? in->i_pts : in->i_dts) );
1025         memcpy( &out->p_buffer[12], p_data, i_payload );
1026
1027         out->i_size   = 12 + i_payload;
1028         out->i_dts    = in->i_dts + i_packet * in->i_length / i_count;
1029         out->i_length = in->i_length / i_count;
1030
1031         sout_AccessOutWrite( id->p_access, out );
1032
1033         p_data += i_payload;
1034         i_data -= i_payload;
1035         i_packet++;
1036     }
1037
1038     return VLC_SUCCESS;
1039 }
1040
1041 static int rtp_packetize_l8( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *in )
1042 {
1043     int     i_max   = id->i_mtu - 12; /* payload max in one packet */
1044     int     i_count = ( in->i_size + i_max - 1 ) / i_max;
1045
1046     uint8_t *p_data = in->p_buffer;
1047     int     i_data  = in->i_size;
1048     int     i_packet = 0;
1049
1050     while( i_data > 0 )
1051     {
1052         int           i_payload = (__MIN( i_max, i_data )/2)*2;
1053         sout_buffer_t *out = sout_BufferNew( p_stream->p_sout, 12 + i_payload );
1054
1055         /* rtp common header */
1056         rtp_packetize_common( id, out, 0, (in->i_pts > 0 ? in->i_pts : in->i_dts) );
1057         memcpy( &out->p_buffer[12], p_data, i_payload );
1058
1059         out->i_size   = 12 + i_payload;
1060         out->i_dts    = in->i_dts + i_packet * in->i_length / i_count;
1061         out->i_length = in->i_length / i_count;
1062
1063         sout_AccessOutWrite( id->p_access, out );
1064
1065         p_data += i_payload;
1066         i_data -= i_payload;
1067         i_packet++;
1068     }
1069
1070     return VLC_SUCCESS;
1071 }
1072 static int rtp_packetize_mp4a( sout_stream_t *p_stream, sout_stream_id_t *id, sout_buffer_t *in )
1073 {
1074     int     i_max   = id->i_mtu - 16; /* payload max in one packet */
1075     int     i_count = ( in->i_size + i_max - 1 ) / i_max;
1076
1077     uint8_t *p_data = in->p_buffer;
1078     int     i_data  = in->i_size;
1079     int     i;
1080
1081     for( i = 0; i < i_count; i++ )
1082     {
1083         int           i_payload = __MIN( i_max, i_data );
1084         sout_buffer_t *out = sout_BufferNew( p_stream->p_sout, 16 + i_payload );
1085
1086         /* rtp common header */
1087         rtp_packetize_common( id, out, ((i == i_count - 1)?1:0), (in->i_pts > 0 ? in->i_pts : in->i_dts) );
1088         /* AU headers */
1089         /* AU headers length (bits) */
1090         out->p_buffer[12] = 0;
1091         out->p_buffer[13] = 2*8;
1092         /* for each AU length 13 bits + idx 3bits, */
1093         out->p_buffer[14] = ( in->i_size >> 5 )&&0xff;
1094         out->p_buffer[15] = ( (in->i_size&&0xff)<<3 )|0;
1095
1096         memcpy( &out->p_buffer[16], p_data, i_payload );
1097
1098         out->i_size   = 16 + i_payload;
1099         out->i_dts    = in->i_dts + i * in->i_length / i_count;
1100         out->i_length = in->i_length / i_count;
1101
1102         sout_AccessOutWrite( id->p_access, out );
1103
1104         p_data += i_payload;
1105         i_data -= i_payload;
1106     }
1107
1108     return VLC_SUCCESS;
1109 }