f401e426a14b004c6a46fe27503555d34defaa0a
[ffmpeg.git] / ffserver.c
1 /*
2  * Multiple format streaming server
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "config.h"
23 #if HAVE_CLOSESOCKET != 1
24 #define closesocket close
25 #endif
26 #include <string.h>
27 #include <stdlib.h>
28 #include "avformat.h"
29
30 #include <stdarg.h>
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <sys/ioctl.h>
34 #ifdef HAVE_SYS_POLL_H
35 #include <sys/poll.h>
36 #endif
37 #include <errno.h>
38 #include <sys/time.h>
39 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
40 #include <time.h>
41 #include <sys/wait.h>
42 #include <signal.h>
43 #ifdef HAVE_DLFCN_H
44 #include <dlfcn.h>
45 #endif
46
47 #include "network.h"
48 #include "version.h"
49 #include "ffserver.h"
50 #include "random.h"
51 #include "avstring.h"
52
53 #undef exit
54
55 /* maximum number of simultaneous HTTP connections */
56 #define HTTP_MAX_CONNECTIONS 2000
57
58 enum HTTPState {
59     HTTPSTATE_WAIT_REQUEST,
60     HTTPSTATE_SEND_HEADER,
61     HTTPSTATE_SEND_DATA_HEADER,
62     HTTPSTATE_SEND_DATA,          /* sending TCP or UDP data */
63     HTTPSTATE_SEND_DATA_TRAILER,
64     HTTPSTATE_RECEIVE_DATA,
65     HTTPSTATE_WAIT_FEED,          /* wait for data from the feed */
66     HTTPSTATE_READY,
67
68     RTSPSTATE_WAIT_REQUEST,
69     RTSPSTATE_SEND_REPLY,
70     RTSPSTATE_SEND_PACKET,
71 };
72
73 const char *http_state[] = {
74     "HTTP_WAIT_REQUEST",
75     "HTTP_SEND_HEADER",
76
77     "SEND_DATA_HEADER",
78     "SEND_DATA",
79     "SEND_DATA_TRAILER",
80     "RECEIVE_DATA",
81     "WAIT_FEED",
82     "READY",
83
84     "RTSP_WAIT_REQUEST",
85     "RTSP_SEND_REPLY",
86     "RTSP_SEND_PACKET",
87 };
88
89 #define IOBUFFER_INIT_SIZE 8192
90
91 /* timeouts are in ms */
92 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
93 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
94
95 #define SYNC_TIMEOUT (10 * 1000)
96
97 typedef struct {
98     int64_t count1, count2;
99     int64_t time1, time2;
100 } DataRateData;
101
102 /* context associated with one connection */
103 typedef struct HTTPContext {
104     enum HTTPState state;
105     int fd; /* socket file descriptor */
106     struct sockaddr_in from_addr; /* origin */
107     struct pollfd *poll_entry; /* used when polling */
108     int64_t timeout;
109     uint8_t *buffer_ptr, *buffer_end;
110     int http_error;
111     int post;
112     struct HTTPContext *next;
113     int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
114     int64_t data_count;
115     /* feed input */
116     int feed_fd;
117     /* input format handling */
118     AVFormatContext *fmt_in;
119     int64_t start_time;            /* In milliseconds - this wraps fairly often */
120     int64_t first_pts;            /* initial pts value */
121     int64_t cur_pts;             /* current pts value from the stream in us */
122     int64_t cur_frame_duration;  /* duration of the current frame in us */
123     int cur_frame_bytes;       /* output frame size, needed to compute
124                                   the time at which we send each
125                                   packet */
126     int pts_stream_index;        /* stream we choose as clock reference */
127     int64_t cur_clock;           /* current clock reference value in us */
128     /* output format handling */
129     struct FFStream *stream;
130     /* -1 is invalid stream */
131     int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
132     int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
133     int switch_pending;
134     AVFormatContext fmt_ctx; /* instance of FFStream for one user */
135     int last_packet_sent; /* true if last data packet was sent */
136     int suppress_log;
137     DataRateData datarate;
138     int wmp_client_id;
139     char protocol[16];
140     char method[16];
141     char url[128];
142     int buffer_size;
143     uint8_t *buffer;
144     int is_packetized; /* if true, the stream is packetized */
145     int packet_stream_index; /* current stream for output in state machine */
146
147     /* RTSP state specific */
148     uint8_t *pb_buffer; /* XXX: use that in all the code */
149     ByteIOContext *pb;
150     int seq; /* RTSP sequence number */
151
152     /* RTP state specific */
153     enum RTSPProtocol rtp_protocol;
154     char session_id[32]; /* session id */
155     AVFormatContext *rtp_ctx[MAX_STREAMS];
156
157     /* RTP/UDP specific */
158     URLContext *rtp_handles[MAX_STREAMS];
159
160     /* RTP/TCP specific */
161     struct HTTPContext *rtsp_c;
162     uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
163 } HTTPContext;
164
165 static AVFrame dummy_frame;
166
167 /* each generated stream is described here */
168 enum StreamType {
169     STREAM_TYPE_LIVE,
170     STREAM_TYPE_STATUS,
171     STREAM_TYPE_REDIRECT,
172 };
173
174 enum IPAddressAction {
175     IP_ALLOW = 1,
176     IP_DENY,
177 };
178
179 typedef struct IPAddressACL {
180     struct IPAddressACL *next;
181     enum IPAddressAction action;
182     /* These are in host order */
183     struct in_addr first;
184     struct in_addr last;
185 } IPAddressACL;
186
187 /* description of each stream of the ffserver.conf file */
188 typedef struct FFStream {
189     enum StreamType stream_type;
190     char filename[1024];     /* stream filename */
191     struct FFStream *feed;   /* feed we are using (can be null if
192                                 coming from file) */
193     AVFormatParameters *ap_in; /* input parameters */
194     AVInputFormat *ifmt;       /* if non NULL, force input format */
195     AVOutputFormat *fmt;
196     IPAddressACL *acl;
197     int nb_streams;
198     int prebuffer;      /* Number of millseconds early to start */
199     int64_t max_time;      /* Number of milliseconds to run */
200     int send_on_key;
201     AVStream *streams[MAX_STREAMS];
202     int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
203     char feed_filename[1024]; /* file name of the feed storage, or
204                                  input file name for a stream */
205     char author[512];
206     char title[512];
207     char copyright[512];
208     char comment[512];
209     pid_t pid;  /* Of ffmpeg process */
210     time_t pid_start;  /* Of ffmpeg process */
211     char **child_argv;
212     struct FFStream *next;
213     int bandwidth; /* bandwidth, in kbits/s */
214     /* RTSP options */
215     char *rtsp_option;
216     /* multicast specific */
217     int is_multicast;
218     struct in_addr multicast_ip;
219     int multicast_port; /* first port used for multicast */
220     int multicast_ttl;
221     int loop; /* if true, send the stream in loops (only meaningful if file) */
222
223     /* feed specific */
224     int feed_opened;     /* true if someone is writing to the feed */
225     int is_feed;         /* true if it is a feed */
226     int readonly;        /* True if writing is prohibited to the file */
227     int conns_served;
228     int64_t bytes_served;
229     int64_t feed_max_size;      /* maximum storage size, zero means unlimited */
230     int64_t feed_write_index;   /* current write position in feed (it wraps round) */
231     int64_t feed_size;          /* current size of feed */
232     struct FFStream *next_feed;
233 } FFStream;
234
235 typedef struct FeedData {
236     long long data_count;
237     float avg_frame_size;   /* frame size averraged over last frames with exponential mean */
238 } FeedData;
239
240 static struct sockaddr_in my_http_addr;
241 static struct sockaddr_in my_rtsp_addr;
242
243 static char logfilename[1024];
244 static HTTPContext *first_http_ctx;
245 static FFStream *first_feed;   /* contains only feeds */
246 static FFStream *first_stream; /* contains all streams, including feeds */
247
248 static void new_connection(int server_fd, int is_rtsp);
249 static void close_connection(HTTPContext *c);
250
251 /* HTTP handling */
252 static int handle_connection(HTTPContext *c);
253 static int http_parse_request(HTTPContext *c);
254 static int http_send_data(HTTPContext *c);
255 static void compute_stats(HTTPContext *c);
256 static int open_input_stream(HTTPContext *c, const char *info);
257 static int http_start_receive_data(HTTPContext *c);
258 static int http_receive_data(HTTPContext *c);
259
260 /* RTSP handling */
261 static int rtsp_parse_request(HTTPContext *c);
262 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
263 static void rtsp_cmd_options(HTTPContext *c, const char *url);
264 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPHeader *h);
265 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h);
266 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h);
267 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h);
268
269 /* SDP handling */
270 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
271                                    struct in_addr my_ip);
272
273 /* RTP handling */
274 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
275                                        FFStream *stream, const char *session_id,
276                                        enum RTSPProtocol rtp_protocol);
277 static int rtp_new_av_stream(HTTPContext *c,
278                              int stream_index, struct sockaddr_in *dest_addr,
279                              HTTPContext *rtsp_c);
280
281 static const char *my_program_name;
282 static const char *my_program_dir;
283
284 static int ffserver_debug;
285 static int ffserver_daemon;
286 static int no_launch;
287 static int need_to_start_children;
288
289 static int nb_max_connections;
290 static int nb_connections;
291
292 static int max_bandwidth;
293 static int current_bandwidth;
294
295 static int64_t cur_time;           // Making this global saves on passing it around everywhere
296
297 static AVRandomState random_state;
298
299 static FILE *logfile = NULL;
300
301 static void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...)
302 {
303     va_list ap;
304     va_start(ap, fmt);
305
306     if (logfile) {
307         vfprintf(logfile, fmt, ap);
308         fflush(logfile);
309     }
310     va_end(ap);
311 }
312
313 static char *ctime1(char *buf2)
314 {
315     time_t ti;
316     char *p;
317
318     ti = time(NULL);
319     p = ctime(&ti);
320     strcpy(buf2, p);
321     p = buf2 + strlen(p) - 1;
322     if (*p == '\n')
323         *p = '\0';
324     return buf2;
325 }
326
327 static void log_connection(HTTPContext *c)
328 {
329     char buf2[32];
330
331     if (c->suppress_log)
332         return;
333
334     http_log("%s - - [%s] \"%s %s %s\" %d %"PRId64"\n",
335              inet_ntoa(c->from_addr.sin_addr),
336              ctime1(buf2), c->method, c->url,
337              c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
338 }
339
340 static void update_datarate(DataRateData *drd, int64_t count)
341 {
342     if (!drd->time1 && !drd->count1) {
343         drd->time1 = drd->time2 = cur_time;
344         drd->count1 = drd->count2 = count;
345     } else if (cur_time - drd->time2 > 5000) {
346             drd->time1 = drd->time2;
347             drd->count1 = drd->count2;
348             drd->time2 = cur_time;
349             drd->count2 = count;
350     }
351 }
352
353 /* In bytes per second */
354 static int compute_datarate(DataRateData *drd, int64_t count)
355 {
356     if (cur_time == drd->time1)
357         return 0;
358
359     return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
360 }
361
362
363 static void start_children(FFStream *feed)
364 {
365     if (no_launch)
366         return;
367
368     for (; feed; feed = feed->next) {
369         if (feed->child_argv && !feed->pid) {
370             feed->pid_start = time(0);
371
372             feed->pid = fork();
373
374             if (feed->pid < 0) {
375                 fprintf(stderr, "Unable to create children\n");
376                 exit(1);
377             }
378             if (!feed->pid) {
379                 /* In child */
380                 char pathname[1024];
381                 char *slash;
382                 int i;
383
384                 for (i = 3; i < 256; i++) {
385                     close(i);
386                 }
387
388                 if (!ffserver_debug) {
389                     i = open("/dev/null", O_RDWR);
390                     if (i)
391                         dup2(i, 0);
392                     dup2(i, 1);
393                     dup2(i, 2);
394                     if (i)
395                         close(i);
396                 }
397
398                 av_strlcpy(pathname, my_program_name, sizeof(pathname));
399
400                 slash = strrchr(pathname, '/');
401                 if (!slash) {
402                     slash = pathname;
403                 } else {
404                     slash++;
405                 }
406                 strcpy(slash, "ffmpeg");
407
408                 /* This is needed to make relative pathnames work */
409                 chdir(my_program_dir);
410
411                 signal(SIGPIPE, SIG_DFL);
412
413                 execvp(pathname, feed->child_argv);
414
415                 _exit(1);
416             }
417         }
418     }
419 }
420
421 /* open a listening socket */
422 static int socket_open_listen(struct sockaddr_in *my_addr)
423 {
424     int server_fd, tmp;
425
426     server_fd = socket(AF_INET,SOCK_STREAM,0);
427     if (server_fd < 0) {
428         perror ("socket");
429         return -1;
430     }
431
432     tmp = 1;
433     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
434
435     if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
436         char bindmsg[32];
437         snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
438         perror (bindmsg);
439         closesocket(server_fd);
440         return -1;
441     }
442
443     if (listen (server_fd, 5) < 0) {
444         perror ("listen");
445         closesocket(server_fd);
446         return -1;
447     }
448     ff_socket_nonblock(server_fd, 1);
449
450     return server_fd;
451 }
452
453 /* start all multicast streams */
454 static void start_multicast(void)
455 {
456     FFStream *stream;
457     char session_id[32];
458     HTTPContext *rtp_c;
459     struct sockaddr_in dest_addr;
460     int default_port, stream_index;
461
462     default_port = 6000;
463     for(stream = first_stream; stream != NULL; stream = stream->next) {
464         if (stream->is_multicast) {
465             /* open the RTP connection */
466             snprintf(session_id, sizeof(session_id), "%08x%08x",
467                      av_random(&random_state), av_random(&random_state));
468
469             /* choose a port if none given */
470             if (stream->multicast_port == 0) {
471                 stream->multicast_port = default_port;
472                 default_port += 100;
473             }
474
475             dest_addr.sin_family = AF_INET;
476             dest_addr.sin_addr = stream->multicast_ip;
477             dest_addr.sin_port = htons(stream->multicast_port);
478
479             rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
480                                        RTSP_PROTOCOL_RTP_UDP_MULTICAST);
481             if (!rtp_c) {
482                 continue;
483             }
484             if (open_input_stream(rtp_c, "") < 0) {
485                 fprintf(stderr, "Could not open input stream for stream '%s'\n",
486                         stream->filename);
487                 continue;
488             }
489
490             /* open each RTP stream */
491             for(stream_index = 0; stream_index < stream->nb_streams;
492                 stream_index++) {
493                 dest_addr.sin_port = htons(stream->multicast_port +
494                                            2 * stream_index);
495                 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
496                     fprintf(stderr, "Could not open output stream '%s/streamid=%d'\n",
497                             stream->filename, stream_index);
498                     exit(1);
499                 }
500             }
501
502             /* change state to send data */
503             rtp_c->state = HTTPSTATE_SEND_DATA;
504         }
505     }
506 }
507
508 /* main loop of the http server */
509 static int http_server(void)
510 {
511     int server_fd, ret, rtsp_server_fd, delay, delay1;
512     struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 2], *poll_entry;
513     HTTPContext *c, *c_next;
514
515     server_fd = socket_open_listen(&my_http_addr);
516     if (server_fd < 0)
517         return -1;
518
519     rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
520     if (rtsp_server_fd < 0)
521         return -1;
522
523     http_log("ffserver started.\n");
524
525     start_children(first_feed);
526
527     first_http_ctx = NULL;
528     nb_connections = 0;
529
530     start_multicast();
531
532     for(;;) {
533         poll_entry = poll_table;
534         poll_entry->fd = server_fd;
535         poll_entry->events = POLLIN;
536         poll_entry++;
537
538         poll_entry->fd = rtsp_server_fd;
539         poll_entry->events = POLLIN;
540         poll_entry++;
541
542         /* wait for events on each HTTP handle */
543         c = first_http_ctx;
544         delay = 1000;
545         while (c != NULL) {
546             int fd;
547             fd = c->fd;
548             switch(c->state) {
549             case HTTPSTATE_SEND_HEADER:
550             case RTSPSTATE_SEND_REPLY:
551             case RTSPSTATE_SEND_PACKET:
552                 c->poll_entry = poll_entry;
553                 poll_entry->fd = fd;
554                 poll_entry->events = POLLOUT;
555                 poll_entry++;
556                 break;
557             case HTTPSTATE_SEND_DATA_HEADER:
558             case HTTPSTATE_SEND_DATA:
559             case HTTPSTATE_SEND_DATA_TRAILER:
560                 if (!c->is_packetized) {
561                     /* for TCP, we output as much as we can (may need to put a limit) */
562                     c->poll_entry = poll_entry;
563                     poll_entry->fd = fd;
564                     poll_entry->events = POLLOUT;
565                     poll_entry++;
566                 } else {
567                     /* when ffserver is doing the timing, we work by
568                        looking at which packet need to be sent every
569                        10 ms */
570                     delay1 = 10; /* one tick wait XXX: 10 ms assumed */
571                     if (delay1 < delay)
572                         delay = delay1;
573                 }
574                 break;
575             case HTTPSTATE_WAIT_REQUEST:
576             case HTTPSTATE_RECEIVE_DATA:
577             case HTTPSTATE_WAIT_FEED:
578             case RTSPSTATE_WAIT_REQUEST:
579                 /* need to catch errors */
580                 c->poll_entry = poll_entry;
581                 poll_entry->fd = fd;
582                 poll_entry->events = POLLIN;/* Maybe this will work */
583                 poll_entry++;
584                 break;
585             default:
586                 c->poll_entry = NULL;
587                 break;
588             }
589             c = c->next;
590         }
591
592         /* wait for an event on one connection. We poll at least every
593            second to handle timeouts */
594         do {
595             ret = poll(poll_table, poll_entry - poll_table, delay);
596             if (ret < 0 && ff_neterrno() != FF_NETERROR(EAGAIN) &&
597                 ff_neterrno() != FF_NETERROR(EINTR))
598                 return -1;
599         } while (ret < 0);
600
601         cur_time = av_gettime() / 1000;
602
603         if (need_to_start_children) {
604             need_to_start_children = 0;
605             start_children(first_feed);
606         }
607
608         /* now handle the events */
609         for(c = first_http_ctx; c != NULL; c = c_next) {
610             c_next = c->next;
611             if (handle_connection(c) < 0) {
612                 /* close and free the connection */
613                 log_connection(c);
614                 close_connection(c);
615             }
616         }
617
618         poll_entry = poll_table;
619         /* new HTTP connection request ? */
620         if (poll_entry->revents & POLLIN) {
621             new_connection(server_fd, 0);
622         }
623         poll_entry++;
624         /* new RTSP connection request ? */
625         if (poll_entry->revents & POLLIN) {
626             new_connection(rtsp_server_fd, 1);
627         }
628     }
629 }
630
631 /* start waiting for a new HTTP/RTSP request */
632 static void start_wait_request(HTTPContext *c, int is_rtsp)
633 {
634     c->buffer_ptr = c->buffer;
635     c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
636
637     if (is_rtsp) {
638         c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
639         c->state = RTSPSTATE_WAIT_REQUEST;
640     } else {
641         c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
642         c->state = HTTPSTATE_WAIT_REQUEST;
643     }
644 }
645
646 static void new_connection(int server_fd, int is_rtsp)
647 {
648     struct sockaddr_in from_addr;
649     int fd, len;
650     HTTPContext *c = NULL;
651
652     len = sizeof(from_addr);
653     fd = accept(server_fd, (struct sockaddr *)&from_addr,
654                 &len);
655     if (fd < 0)
656         return;
657     ff_socket_nonblock(fd, 1);
658
659     /* XXX: should output a warning page when coming
660        close to the connection limit */
661     if (nb_connections >= nb_max_connections)
662         goto fail;
663
664     /* add a new connection */
665     c = av_mallocz(sizeof(HTTPContext));
666     if (!c)
667         goto fail;
668
669     c->fd = fd;
670     c->poll_entry = NULL;
671     c->from_addr = from_addr;
672     c->buffer_size = IOBUFFER_INIT_SIZE;
673     c->buffer = av_malloc(c->buffer_size);
674     if (!c->buffer)
675         goto fail;
676
677     c->next = first_http_ctx;
678     first_http_ctx = c;
679     nb_connections++;
680
681     start_wait_request(c, is_rtsp);
682
683     return;
684
685  fail:
686     if (c) {
687         av_free(c->buffer);
688         av_free(c);
689     }
690     closesocket(fd);
691 }
692
693 static void close_connection(HTTPContext *c)
694 {
695     HTTPContext **cp, *c1;
696     int i, nb_streams;
697     AVFormatContext *ctx;
698     URLContext *h;
699     AVStream *st;
700
701     /* remove connection from list */
702     cp = &first_http_ctx;
703     while ((*cp) != NULL) {
704         c1 = *cp;
705         if (c1 == c) {
706             *cp = c->next;
707         } else {
708             cp = &c1->next;
709         }
710     }
711
712     /* remove references, if any (XXX: do it faster) */
713     for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
714         if (c1->rtsp_c == c)
715             c1->rtsp_c = NULL;
716     }
717
718     /* remove connection associated resources */
719     if (c->fd >= 0)
720         closesocket(c->fd);
721     if (c->fmt_in) {
722         /* close each frame parser */
723         for(i=0;i<c->fmt_in->nb_streams;i++) {
724             st = c->fmt_in->streams[i];
725             if (st->codec->codec) {
726                 avcodec_close(st->codec);
727             }
728         }
729         av_close_input_file(c->fmt_in);
730     }
731
732     /* free RTP output streams if any */
733     nb_streams = 0;
734     if (c->stream)
735         nb_streams = c->stream->nb_streams;
736
737     for(i=0;i<nb_streams;i++) {
738         ctx = c->rtp_ctx[i];
739         if (ctx) {
740             av_write_trailer(ctx);
741             av_free(ctx);
742         }
743         h = c->rtp_handles[i];
744         if (h) {
745             url_close(h);
746         }
747     }
748
749     ctx = &c->fmt_ctx;
750
751     if (!c->last_packet_sent) {
752         if (ctx->oformat) {
753             /* prepare header */
754             if (url_open_dyn_buf(&ctx->pb) >= 0) {
755                 av_write_trailer(ctx);
756                 url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
757             }
758         }
759     }
760
761     for(i=0; i<ctx->nb_streams; i++)
762         av_free(ctx->streams[i]) ;
763
764     if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
765         current_bandwidth -= c->stream->bandwidth;
766
767     /* signal that there is no feed if we are the feeder socket */
768     if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
769         c->stream->feed_opened = 0;
770         close(c->feed_fd);
771     }
772
773     av_freep(&c->pb_buffer);
774     av_freep(&c->packet_buffer);
775     av_free(c->buffer);
776     av_free(c);
777     nb_connections--;
778 }
779
780 static int handle_connection(HTTPContext *c)
781 {
782     int len, ret;
783
784     switch(c->state) {
785     case HTTPSTATE_WAIT_REQUEST:
786     case RTSPSTATE_WAIT_REQUEST:
787         /* timeout ? */
788         if ((c->timeout - cur_time) < 0)
789             return -1;
790         if (c->poll_entry->revents & (POLLERR | POLLHUP))
791             return -1;
792
793         /* no need to read if no events */
794         if (!(c->poll_entry->revents & POLLIN))
795             return 0;
796         /* read the data */
797     read_loop:
798         len = recv(c->fd, c->buffer_ptr, 1, 0);
799         if (len < 0) {
800             if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
801                 ff_neterrno() != FF_NETERROR(EINTR))
802                 return -1;
803         } else if (len == 0) {
804             return -1;
805         } else {
806             /* search for end of request. */
807             uint8_t *ptr;
808             c->buffer_ptr += len;
809             ptr = c->buffer_ptr;
810             if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
811                 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
812                 /* request found : parse it and reply */
813                 if (c->state == HTTPSTATE_WAIT_REQUEST) {
814                     ret = http_parse_request(c);
815                 } else {
816                     ret = rtsp_parse_request(c);
817                 }
818                 if (ret < 0)
819                     return -1;
820             } else if (ptr >= c->buffer_end) {
821                 /* request too long: cannot do anything */
822                 return -1;
823             } else goto read_loop;
824         }
825         break;
826
827     case HTTPSTATE_SEND_HEADER:
828         if (c->poll_entry->revents & (POLLERR | POLLHUP))
829             return -1;
830
831         /* no need to write if no events */
832         if (!(c->poll_entry->revents & POLLOUT))
833             return 0;
834         len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
835         if (len < 0) {
836             if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
837                 ff_neterrno() != FF_NETERROR(EINTR)) {
838                 /* error : close connection */
839                 av_freep(&c->pb_buffer);
840                 return -1;
841             }
842         } else {
843             c->buffer_ptr += len;
844             if (c->stream)
845                 c->stream->bytes_served += len;
846             c->data_count += len;
847             if (c->buffer_ptr >= c->buffer_end) {
848                 av_freep(&c->pb_buffer);
849                 /* if error, exit */
850                 if (c->http_error) {
851                     return -1;
852                 }
853                 /* all the buffer was sent : synchronize to the incoming stream */
854                 c->state = HTTPSTATE_SEND_DATA_HEADER;
855                 c->buffer_ptr = c->buffer_end = c->buffer;
856             }
857         }
858         break;
859
860     case HTTPSTATE_SEND_DATA:
861     case HTTPSTATE_SEND_DATA_HEADER:
862     case HTTPSTATE_SEND_DATA_TRAILER:
863         /* for packetized output, we consider we can always write (the
864            input streams sets the speed). It may be better to verify
865            that we do not rely too much on the kernel queues */
866         if (!c->is_packetized) {
867             if (c->poll_entry->revents & (POLLERR | POLLHUP))
868                 return -1;
869
870             /* no need to read if no events */
871             if (!(c->poll_entry->revents & POLLOUT))
872                 return 0;
873         }
874         if (http_send_data(c) < 0)
875             return -1;
876         /* close connection if trailer sent */
877         if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
878             return -1;
879         break;
880     case HTTPSTATE_RECEIVE_DATA:
881         /* no need to read if no events */
882         if (c->poll_entry->revents & (POLLERR | POLLHUP))
883             return -1;
884         if (!(c->poll_entry->revents & POLLIN))
885             return 0;
886         if (http_receive_data(c) < 0)
887             return -1;
888         break;
889     case HTTPSTATE_WAIT_FEED:
890         /* no need to read if no events */
891         if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
892             return -1;
893
894         /* nothing to do, we'll be waken up by incoming feed packets */
895         break;
896
897     case RTSPSTATE_SEND_REPLY:
898         if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
899             av_freep(&c->pb_buffer);
900             return -1;
901         }
902         /* no need to write if no events */
903         if (!(c->poll_entry->revents & POLLOUT))
904             return 0;
905         len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
906         if (len < 0) {
907             if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
908                 ff_neterrno() != FF_NETERROR(EINTR)) {
909                 /* error : close connection */
910                 av_freep(&c->pb_buffer);
911                 return -1;
912             }
913         } else {
914             c->buffer_ptr += len;
915             c->data_count += len;
916             if (c->buffer_ptr >= c->buffer_end) {
917                 /* all the buffer was sent : wait for a new request */
918                 av_freep(&c->pb_buffer);
919                 start_wait_request(c, 1);
920             }
921         }
922         break;
923     case RTSPSTATE_SEND_PACKET:
924         if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
925             av_freep(&c->packet_buffer);
926             return -1;
927         }
928         /* no need to write if no events */
929         if (!(c->poll_entry->revents & POLLOUT))
930             return 0;
931         len = send(c->fd, c->packet_buffer_ptr,
932                     c->packet_buffer_end - c->packet_buffer_ptr, 0);
933         if (len < 0) {
934             if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
935                 ff_neterrno() != FF_NETERROR(EINTR)) {
936                 /* error : close connection */
937                 av_freep(&c->packet_buffer);
938                 return -1;
939             }
940         } else {
941             c->packet_buffer_ptr += len;
942             if (c->packet_buffer_ptr >= c->packet_buffer_end) {
943                 /* all the buffer was sent : wait for a new request */
944                 av_freep(&c->packet_buffer);
945                 c->state = RTSPSTATE_WAIT_REQUEST;
946             }
947         }
948         break;
949     case HTTPSTATE_READY:
950         /* nothing to do */
951         break;
952     default:
953         return -1;
954     }
955     return 0;
956 }
957
958 static int extract_rates(char *rates, int ratelen, const char *request)
959 {
960     const char *p;
961
962     for (p = request; *p && *p != '\r' && *p != '\n'; ) {
963         if (strncasecmp(p, "Pragma:", 7) == 0) {
964             const char *q = p + 7;
965
966             while (*q && *q != '\n' && isspace(*q))
967                 q++;
968
969             if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
970                 int stream_no;
971                 int rate_no;
972
973                 q += 20;
974
975                 memset(rates, 0xff, ratelen);
976
977                 while (1) {
978                     while (*q && *q != '\n' && *q != ':')
979                         q++;
980
981                     if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2) {
982                         break;
983                     }
984                     stream_no--;
985                     if (stream_no < ratelen && stream_no >= 0) {
986                         rates[stream_no] = rate_no;
987                     }
988
989                     while (*q && *q != '\n' && !isspace(*q))
990                         q++;
991                 }
992
993                 return 1;
994             }
995         }
996         p = strchr(p, '\n');
997         if (!p)
998             break;
999
1000         p++;
1001     }
1002
1003     return 0;
1004 }
1005
1006 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1007 {
1008     int i;
1009     int best_bitrate = 100000000;
1010     int best = -1;
1011
1012     for (i = 0; i < feed->nb_streams; i++) {
1013         AVCodecContext *feed_codec = feed->streams[i]->codec;
1014
1015         if (feed_codec->codec_id != codec->codec_id ||
1016             feed_codec->sample_rate != codec->sample_rate ||
1017             feed_codec->width != codec->width ||
1018             feed_codec->height != codec->height) {
1019             continue;
1020         }
1021
1022         /* Potential stream */
1023
1024         /* We want the fastest stream less than bit_rate, or the slowest
1025          * faster than bit_rate
1026          */
1027
1028         if (feed_codec->bit_rate <= bit_rate) {
1029             if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1030                 best_bitrate = feed_codec->bit_rate;
1031                 best = i;
1032             }
1033         } else {
1034             if (feed_codec->bit_rate < best_bitrate) {
1035                 best_bitrate = feed_codec->bit_rate;
1036                 best = i;
1037             }
1038         }
1039     }
1040
1041     return best;
1042 }
1043
1044 static int modify_current_stream(HTTPContext *c, char *rates)
1045 {
1046     int i;
1047     FFStream *req = c->stream;
1048     int action_required = 0;
1049
1050     /* Not much we can do for a feed */
1051     if (!req->feed)
1052         return 0;
1053
1054     for (i = 0; i < req->nb_streams; i++) {
1055         AVCodecContext *codec = req->streams[i]->codec;
1056
1057         switch(rates[i]) {
1058             case 0:
1059                 c->switch_feed_streams[i] = req->feed_streams[i];
1060                 break;
1061             case 1:
1062                 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1063                 break;
1064             case 2:
1065                 /* Wants off or slow */
1066                 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1067 #ifdef WANTS_OFF
1068                 /* This doesn't work well when it turns off the only stream! */
1069                 c->switch_feed_streams[i] = -2;
1070                 c->feed_streams[i] = -2;
1071 #endif
1072                 break;
1073         }
1074
1075         if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1076             action_required = 1;
1077     }
1078
1079     return action_required;
1080 }
1081
1082
1083 static void do_switch_stream(HTTPContext *c, int i)
1084 {
1085     if (c->switch_feed_streams[i] >= 0) {
1086 #ifdef PHILIP
1087         c->feed_streams[i] = c->switch_feed_streams[i];
1088 #endif
1089
1090         /* Now update the stream */
1091     }
1092     c->switch_feed_streams[i] = -1;
1093 }
1094
1095 /* XXX: factorize in utils.c ? */
1096 /* XXX: take care with different space meaning */
1097 static void skip_spaces(const char **pp)
1098 {
1099     const char *p;
1100     p = *pp;
1101     while (*p == ' ' || *p == '\t')
1102         p++;
1103     *pp = p;
1104 }
1105
1106 static void get_word(char *buf, int buf_size, const char **pp)
1107 {
1108     const char *p;
1109     char *q;
1110
1111     p = *pp;
1112     skip_spaces(&p);
1113     q = buf;
1114     while (!isspace(*p) && *p != '\0') {
1115         if ((q - buf) < buf_size - 1)
1116             *q++ = *p;
1117         p++;
1118     }
1119     if (buf_size > 0)
1120         *q = '\0';
1121     *pp = p;
1122 }
1123
1124 static int validate_acl(FFStream *stream, HTTPContext *c)
1125 {
1126     enum IPAddressAction last_action = IP_DENY;
1127     IPAddressACL *acl;
1128     struct in_addr *src = &c->from_addr.sin_addr;
1129     unsigned long src_addr = src->s_addr;
1130
1131     for (acl = stream->acl; acl; acl = acl->next) {
1132         if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr) {
1133             return (acl->action == IP_ALLOW) ? 1 : 0;
1134         }
1135         last_action = acl->action;
1136     }
1137
1138     /* Nothing matched, so return not the last action */
1139     return (last_action == IP_DENY) ? 1 : 0;
1140 }
1141
1142 /* compute the real filename of a file by matching it without its
1143    extensions to all the stream filenames */
1144 static void compute_real_filename(char *filename, int max_size)
1145 {
1146     char file1[1024];
1147     char file2[1024];
1148     char *p;
1149     FFStream *stream;
1150
1151     /* compute filename by matching without the file extensions */
1152     av_strlcpy(file1, filename, sizeof(file1));
1153     p = strrchr(file1, '.');
1154     if (p)
1155         *p = '\0';
1156     for(stream = first_stream; stream != NULL; stream = stream->next) {
1157         av_strlcpy(file2, stream->filename, sizeof(file2));
1158         p = strrchr(file2, '.');
1159         if (p)
1160             *p = '\0';
1161         if (!strcmp(file1, file2)) {
1162             av_strlcpy(filename, stream->filename, max_size);
1163             break;
1164         }
1165     }
1166 }
1167
1168 enum RedirType {
1169     REDIR_NONE,
1170     REDIR_ASX,
1171     REDIR_RAM,
1172     REDIR_ASF,
1173     REDIR_RTSP,
1174     REDIR_SDP,
1175 };
1176
1177 /* parse http request and prepare header */
1178 static int http_parse_request(HTTPContext *c)
1179 {
1180     char *p;
1181     enum RedirType redir_type;
1182     char cmd[32];
1183     char info[1024], filename[1024];
1184     char url[1024], *q;
1185     char protocol[32];
1186     char msg[1024];
1187     const char *mime_type;
1188     FFStream *stream;
1189     int i;
1190     char ratebuf[32];
1191     char *useragent = 0;
1192
1193     p = c->buffer;
1194     get_word(cmd, sizeof(cmd), (const char **)&p);
1195     av_strlcpy(c->method, cmd, sizeof(c->method));
1196
1197     if (!strcmp(cmd, "GET"))
1198         c->post = 0;
1199     else if (!strcmp(cmd, "POST"))
1200         c->post = 1;
1201     else
1202         return -1;
1203
1204     get_word(url, sizeof(url), (const char **)&p);
1205     av_strlcpy(c->url, url, sizeof(c->url));
1206
1207     get_word(protocol, sizeof(protocol), (const char **)&p);
1208     if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1209         return -1;
1210
1211     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1212
1213     if (ffserver_debug)
1214         http_log("New connection: %s %s\n", cmd, url);
1215
1216     /* find the filename and the optional info string in the request */
1217     p = strchr(url, '?');
1218     if (p) {
1219         av_strlcpy(info, p, sizeof(info));
1220         *p = '\0';
1221     } else {
1222         info[0] = '\0';
1223     }
1224
1225     av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1226
1227     for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1228         if (strncasecmp(p, "User-Agent:", 11) == 0) {
1229             useragent = p + 11;
1230             if (*useragent && *useragent != '\n' && isspace(*useragent))
1231                 useragent++;
1232             break;
1233         }
1234         p = strchr(p, '\n');
1235         if (!p)
1236             break;
1237
1238         p++;
1239     }
1240
1241     redir_type = REDIR_NONE;
1242     if (match_ext(filename, "asx")) {
1243         redir_type = REDIR_ASX;
1244         filename[strlen(filename)-1] = 'f';
1245     } else if (match_ext(filename, "asf") &&
1246         (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1247         /* if this isn't WMP or lookalike, return the redirector file */
1248         redir_type = REDIR_ASF;
1249     } else if (match_ext(filename, "rpm,ram")) {
1250         redir_type = REDIR_RAM;
1251         strcpy(filename + strlen(filename)-2, "m");
1252     } else if (match_ext(filename, "rtsp")) {
1253         redir_type = REDIR_RTSP;
1254         compute_real_filename(filename, sizeof(filename) - 1);
1255     } else if (match_ext(filename, "sdp")) {
1256         redir_type = REDIR_SDP;
1257         compute_real_filename(filename, sizeof(filename) - 1);
1258     }
1259
1260     // "redirect" / request to index.html
1261     if (!strlen(filename))
1262         av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1263
1264     stream = first_stream;
1265     while (stream != NULL) {
1266         if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1267             break;
1268         stream = stream->next;
1269     }
1270     if (stream == NULL) {
1271         snprintf(msg, sizeof(msg), "File '%s' not found", url);
1272         goto send_error;
1273     }
1274
1275     c->stream = stream;
1276     memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1277     memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1278
1279     if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1280         c->http_error = 301;
1281         q = c->buffer;
1282         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 301 Moved\r\n");
1283         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Location: %s\r\n", stream->feed_filename);
1284         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: text/html\r\n");
1285         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1286         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<html><head><title>Moved</title></head><body>\r\n");
1287         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "You should be <a href=\"%s\">redirected</a>.\r\n", stream->feed_filename);
1288         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</body></html>\r\n");
1289
1290         /* prepare output buffer */
1291         c->buffer_ptr = c->buffer;
1292         c->buffer_end = q;
1293         c->state = HTTPSTATE_SEND_HEADER;
1294         return 0;
1295     }
1296
1297     /* If this is WMP, get the rate information */
1298     if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1299         if (modify_current_stream(c, ratebuf)) {
1300             for (i = 0; i < sizeof(c->feed_streams) / sizeof(c->feed_streams[0]); i++) {
1301                 if (c->switch_feed_streams[i] >= 0)
1302                     do_switch_stream(c, i);
1303             }
1304         }
1305     }
1306
1307     /* If already streaming this feed, do not let start another feeder. */
1308     if (stream->feed_opened) {
1309         snprintf(msg, sizeof(msg), "This feed is already being received.");
1310         goto send_error;
1311     }
1312
1313     if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE) {
1314         current_bandwidth += stream->bandwidth;
1315     }
1316
1317     if (c->post == 0 && max_bandwidth < current_bandwidth) {
1318         c->http_error = 200;
1319         q = c->buffer;
1320         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 Server too busy\r\n");
1321         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: text/html\r\n");
1322         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1323         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<html><head><title>Too busy</title></head><body>\r\n");
1324         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<p>The server is too busy to serve your request at this time.</p>\r\n");
1325         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<p>The bandwidth being served (including your stream) is %dkbit/sec, and this exceeds the limit of %dkbit/sec.</p>\r\n",
1326             current_bandwidth, max_bandwidth);
1327         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</body></html>\r\n");
1328
1329         /* prepare output buffer */
1330         c->buffer_ptr = c->buffer;
1331         c->buffer_end = q;
1332         c->state = HTTPSTATE_SEND_HEADER;
1333         return 0;
1334     }
1335
1336     if (redir_type != REDIR_NONE) {
1337         char *hostinfo = 0;
1338
1339         for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1340             if (strncasecmp(p, "Host:", 5) == 0) {
1341                 hostinfo = p + 5;
1342                 break;
1343             }
1344             p = strchr(p, '\n');
1345             if (!p)
1346                 break;
1347
1348             p++;
1349         }
1350
1351         if (hostinfo) {
1352             char *eoh;
1353             char hostbuf[260];
1354
1355             while (isspace(*hostinfo))
1356                 hostinfo++;
1357
1358             eoh = strchr(hostinfo, '\n');
1359             if (eoh) {
1360                 if (eoh[-1] == '\r')
1361                     eoh--;
1362
1363                 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1364                     memcpy(hostbuf, hostinfo, eoh - hostinfo);
1365                     hostbuf[eoh - hostinfo] = 0;
1366
1367                     c->http_error = 200;
1368                     q = c->buffer;
1369                     switch(redir_type) {
1370                     case REDIR_ASX:
1371                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASX Follows\r\n");
1372                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1373                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1374                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ASX Version=\"3\">\r\n");
1375                         //q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<!-- Autogenerated by ffserver -->\r\n");
1376                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n",
1377                                 hostbuf, filename, info);
1378                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</ASX>\r\n");
1379                         break;
1380                     case REDIR_RAM:
1381                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RAM Follows\r\n");
1382                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: audio/x-pn-realaudio\r\n");
1383                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1384                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "# Autogenerated by ffserver\r\n");
1385                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "http://%s/%s%s\r\n",
1386                                 hostbuf, filename, info);
1387                         break;
1388                     case REDIR_ASF:
1389                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASF Redirect follows\r\n");
1390                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1391                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1392                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "[Reference]\r\n");
1393                         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Ref1=http://%s/%s%s\r\n",
1394                                 hostbuf, filename, info);
1395                         break;
1396                     case REDIR_RTSP:
1397                         {
1398                             char hostname[256], *p;
1399                             /* extract only hostname */
1400                             av_strlcpy(hostname, hostbuf, sizeof(hostname));
1401                             p = strrchr(hostname, ':');
1402                             if (p)
1403                                 *p = '\0';
1404                             q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RTSP Redirect follows\r\n");
1405                             /* XXX: incorrect mime type ? */
1406                             q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/x-rtsp\r\n");
1407                             q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1408                             q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "rtsp://%s:%d/%s\r\n",
1409                                          hostname, ntohs(my_rtsp_addr.sin_port),
1410                                          filename);
1411                         }
1412                         break;
1413                     case REDIR_SDP:
1414                         {
1415                             uint8_t *sdp_data;
1416                             int sdp_data_size, len;
1417                             struct sockaddr_in my_addr;
1418
1419                             q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1420                             q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/sdp\r\n");
1421                             q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1422
1423                             len = sizeof(my_addr);
1424                             getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1425
1426                             /* XXX: should use a dynamic buffer */
1427                             sdp_data_size = prepare_sdp_description(stream,
1428                                                                     &sdp_data,
1429                                                                     my_addr.sin_addr);
1430                             if (sdp_data_size > 0) {
1431                                 memcpy(q, sdp_data, sdp_data_size);
1432                                 q += sdp_data_size;
1433                                 *q = '\0';
1434                                 av_free(sdp_data);
1435                             }
1436                         }
1437                         break;
1438                     default:
1439                         abort();
1440                         break;
1441                     }
1442
1443                     /* prepare output buffer */
1444                     c->buffer_ptr = c->buffer;
1445                     c->buffer_end = q;
1446                     c->state = HTTPSTATE_SEND_HEADER;
1447                     return 0;
1448                 }
1449             }
1450         }
1451
1452         snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1453         goto send_error;
1454     }
1455
1456     stream->conns_served++;
1457
1458     /* XXX: add there authenticate and IP match */
1459
1460     if (c->post) {
1461         /* if post, it means a feed is being sent */
1462         if (!stream->is_feed) {
1463             /* However it might be a status report from WMP! Lets log the data
1464              * as it might come in handy one day
1465              */
1466             char *logline = 0;
1467             int client_id = 0;
1468
1469             for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1470                 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1471                     logline = p;
1472                     break;
1473                 }
1474                 if (strncasecmp(p, "Pragma: client-id=", 18) == 0) {
1475                     client_id = strtol(p + 18, 0, 10);
1476                 }
1477                 p = strchr(p, '\n');
1478                 if (!p)
1479                     break;
1480
1481                 p++;
1482             }
1483
1484             if (logline) {
1485                 char *eol = strchr(logline, '\n');
1486
1487                 logline += 17;
1488
1489                 if (eol) {
1490                     if (eol[-1] == '\r')
1491                         eol--;
1492                     http_log("%.*s\n", (int) (eol - logline), logline);
1493                     c->suppress_log = 1;
1494                 }
1495             }
1496
1497 #ifdef DEBUG_WMP
1498             http_log("\nGot request:\n%s\n", c->buffer);
1499 #endif
1500
1501             if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1502                 HTTPContext *wmpc;
1503
1504                 /* Now we have to find the client_id */
1505                 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1506                     if (wmpc->wmp_client_id == client_id)
1507                         break;
1508                 }
1509
1510                 if (wmpc) {
1511                     if (modify_current_stream(wmpc, ratebuf)) {
1512                         wmpc->switch_pending = 1;
1513                     }
1514                 }
1515             }
1516
1517             snprintf(msg, sizeof(msg), "POST command not handled");
1518             c->stream = 0;
1519             goto send_error;
1520         }
1521         if (http_start_receive_data(c) < 0) {
1522             snprintf(msg, sizeof(msg), "could not open feed");
1523             goto send_error;
1524         }
1525         c->http_error = 0;
1526         c->state = HTTPSTATE_RECEIVE_DATA;
1527         return 0;
1528     }
1529
1530 #ifdef DEBUG_WMP
1531     if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0) {
1532         http_log("\nGot request:\n%s\n", c->buffer);
1533     }
1534 #endif
1535
1536     if (c->stream->stream_type == STREAM_TYPE_STATUS)
1537         goto send_stats;
1538
1539     /* open input stream */
1540     if (open_input_stream(c, info) < 0) {
1541         snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1542         goto send_error;
1543     }
1544
1545     /* prepare http header */
1546     q = c->buffer;
1547     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1548     mime_type = c->stream->fmt->mime_type;
1549     if (!mime_type)
1550         mime_type = "application/x-octet-stream";
1551     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1552
1553     /* for asf, we need extra headers */
1554     if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1555         /* Need to allocate a client id */
1556
1557         c->wmp_client_id = av_random(&random_state) & 0x7fffffff;
1558
1559         q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Server: Cougar 4.1.0.3923\r\nCache-Control: no-cache\r\nPragma: client-id=%d\r\nPragma: features=\"broadcast\"\r\n", c->wmp_client_id);
1560     }
1561     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1562     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1563
1564     /* prepare output buffer */
1565     c->http_error = 0;
1566     c->buffer_ptr = c->buffer;
1567     c->buffer_end = q;
1568     c->state = HTTPSTATE_SEND_HEADER;
1569     return 0;
1570  send_error:
1571     c->http_error = 404;
1572     q = c->buffer;
1573     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 404 Not Found\r\n");
1574     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: %s\r\n", "text/html");
1575     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1576     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HTML>\n");
1577     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n");
1578     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<BODY>%s</BODY>\n", msg);
1579     q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</HTML>\n");
1580
1581     /* prepare output buffer */
1582     c->buffer_ptr = c->buffer;
1583     c->buffer_end = q;
1584     c->state = HTTPSTATE_SEND_HEADER;
1585     return 0;
1586  send_stats:
1587     compute_stats(c);
1588     c->http_error = 200; /* horrible : we use this value to avoid
1589                             going to the send data state */
1590     c->state = HTTPSTATE_SEND_HEADER;
1591     return 0;
1592 }
1593
1594 static void fmt_bytecount(ByteIOContext *pb, int64_t count)
1595 {
1596     static const char *suffix = " kMGTP";
1597     const char *s;
1598
1599     for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++) {
1600     }
1601
1602     url_fprintf(pb, "%"PRId64"%c", count, *s);
1603 }
1604
1605 static void compute_stats(HTTPContext *c)
1606 {
1607     HTTPContext *c1;
1608     FFStream *stream;
1609     char *p;
1610     time_t ti;
1611     int i, len;
1612     ByteIOContext pb1, *pb = &pb1;
1613
1614     if (url_open_dyn_buf(pb) < 0) {
1615         /* XXX: return an error ? */
1616         c->buffer_ptr = c->buffer;
1617         c->buffer_end = c->buffer;
1618         return;
1619     }
1620
1621     url_fprintf(pb, "HTTP/1.0 200 OK\r\n");
1622     url_fprintf(pb, "Content-type: %s\r\n", "text/html");
1623     url_fprintf(pb, "Pragma: no-cache\r\n");
1624     url_fprintf(pb, "\r\n");
1625
1626     url_fprintf(pb, "<HEAD><TITLE>FFServer Status</TITLE>\n");
1627     if (c->stream->feed_filename) {
1628         url_fprintf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1629     }
1630     url_fprintf(pb, "</HEAD>\n<BODY>");
1631     url_fprintf(pb, "<H1>FFServer Status</H1>\n");
1632     /* format status */
1633     url_fprintf(pb, "<H2>Available Streams</H2>\n");
1634     url_fprintf(pb, "<TABLE cellspacing=0 cellpadding=4>\n");
1635     url_fprintf(pb, "<TR><Th valign=top>Path<th align=left>Served<br>Conns<Th><br>bytes<Th valign=top>Format<Th>Bit rate<br>kbits/s<Th align=left>Video<br>kbits/s<th><br>Codec<Th align=left>Audio<br>kbits/s<th><br>Codec<Th align=left valign=top>Feed\n");
1636     stream = first_stream;
1637     while (stream != NULL) {
1638         char sfilename[1024];
1639         char *eosf;
1640
1641         if (stream->feed != stream) {
1642             av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1643             eosf = sfilename + strlen(sfilename);
1644             if (eosf - sfilename >= 4) {
1645                 if (strcmp(eosf - 4, ".asf") == 0) {
1646                     strcpy(eosf - 4, ".asx");
1647                 } else if (strcmp(eosf - 3, ".rm") == 0) {
1648                     strcpy(eosf - 3, ".ram");
1649                 } else if (stream->fmt == &rtp_muxer) {
1650                     /* generate a sample RTSP director if
1651                        unicast. Generate an SDP redirector if
1652                        multicast */
1653                     eosf = strrchr(sfilename, '.');
1654                     if (!eosf)
1655                         eosf = sfilename + strlen(sfilename);
1656                     if (stream->is_multicast)
1657                         strcpy(eosf, ".sdp");
1658                     else
1659                         strcpy(eosf, ".rtsp");
1660                 }
1661             }
1662
1663             url_fprintf(pb, "<TR><TD><A HREF=\"/%s\">%s</A> ",
1664                          sfilename, stream->filename);
1665             url_fprintf(pb, "<td align=right> %d <td align=right> ",
1666                         stream->conns_served);
1667             fmt_bytecount(pb, stream->bytes_served);
1668             switch(stream->stream_type) {
1669             case STREAM_TYPE_LIVE:
1670                 {
1671                     int audio_bit_rate = 0;
1672                     int video_bit_rate = 0;
1673                     const char *audio_codec_name = "";
1674                     const char *video_codec_name = "";
1675                     const char *audio_codec_name_extra = "";
1676                     const char *video_codec_name_extra = "";
1677
1678                     for(i=0;i<stream->nb_streams;i++) {
1679                         AVStream *st = stream->streams[i];
1680                         AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1681                         switch(st->codec->codec_type) {
1682                         case CODEC_TYPE_AUDIO:
1683                             audio_bit_rate += st->codec->bit_rate;
1684                             if (codec) {
1685                                 if (*audio_codec_name)
1686                                     audio_codec_name_extra = "...";
1687                                 audio_codec_name = codec->name;
1688                             }
1689                             break;
1690                         case CODEC_TYPE_VIDEO:
1691                             video_bit_rate += st->codec->bit_rate;
1692                             if (codec) {
1693                                 if (*video_codec_name)
1694                                     video_codec_name_extra = "...";
1695                                 video_codec_name = codec->name;
1696                             }
1697                             break;
1698                         case CODEC_TYPE_DATA:
1699                             video_bit_rate += st->codec->bit_rate;
1700                             break;
1701                         default:
1702                             abort();
1703                         }
1704                     }
1705                     url_fprintf(pb, "<TD align=center> %s <TD align=right> %d <TD align=right> %d <TD> %s %s <TD align=right> %d <TD> %s %s",
1706                                  stream->fmt->name,
1707                                  stream->bandwidth,
1708                                  video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1709                                  audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1710                     if (stream->feed) {
1711                         url_fprintf(pb, "<TD>%s", stream->feed->filename);
1712                     } else {
1713                         url_fprintf(pb, "<TD>%s", stream->feed_filename);
1714                     }
1715                     url_fprintf(pb, "\n");
1716                 }
1717                 break;
1718             default:
1719                 url_fprintf(pb, "<TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD>\n");
1720                 break;
1721             }
1722         }
1723         stream = stream->next;
1724     }
1725     url_fprintf(pb, "</TABLE>\n");
1726
1727     stream = first_stream;
1728     while (stream != NULL) {
1729         if (stream->feed == stream) {
1730             url_fprintf(pb, "<h2>Feed %s</h2>", stream->filename);
1731             if (stream->pid) {
1732                 url_fprintf(pb, "Running as pid %d.\n", stream->pid);
1733
1734 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1735                 {
1736                     FILE *pid_stat;
1737                     char ps_cmd[64];
1738
1739                     /* This is somewhat linux specific I guess */
1740                     snprintf(ps_cmd, sizeof(ps_cmd),
1741                              "ps -o \"%%cpu,cputime\" --no-headers %d",
1742                              stream->pid);
1743
1744                     pid_stat = popen(ps_cmd, "r");
1745                     if (pid_stat) {
1746                         char cpuperc[10];
1747                         char cpuused[64];
1748
1749                         if (fscanf(pid_stat, "%10s %64s", cpuperc,
1750                                    cpuused) == 2) {
1751                             url_fprintf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
1752                                          cpuperc, cpuused);
1753                         }
1754                         fclose(pid_stat);
1755                     }
1756                 }
1757 #endif
1758
1759                 url_fprintf(pb, "<p>");
1760             }
1761             url_fprintf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
1762
1763             for (i = 0; i < stream->nb_streams; i++) {
1764                 AVStream *st = stream->streams[i];
1765                 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1766                 const char *type = "unknown";
1767                 char parameters[64];
1768
1769                 parameters[0] = 0;
1770
1771                 switch(st->codec->codec_type) {
1772                 case CODEC_TYPE_AUDIO:
1773                     type = "audio";
1774                     snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
1775                     break;
1776                 case CODEC_TYPE_VIDEO:
1777                     type = "video";
1778                     snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
1779                                 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
1780                     break;
1781                 default:
1782                     abort();
1783                 }
1784                 url_fprintf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
1785                         i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
1786             }
1787             url_fprintf(pb, "</table>\n");
1788
1789         }
1790         stream = stream->next;
1791     }
1792
1793 #if 0
1794     {
1795         float avg;
1796         AVCodecContext *enc;
1797         char buf[1024];
1798
1799         /* feed status */
1800         stream = first_feed;
1801         while (stream != NULL) {
1802             url_fprintf(pb, "<H1>Feed '%s'</H1>\n", stream->filename);
1803             url_fprintf(pb, "<TABLE>\n");
1804             url_fprintf(pb, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
1805             for(i=0;i<stream->nb_streams;i++) {
1806                 AVStream *st = stream->streams[i];
1807                 FeedData *fdata = st->priv_data;
1808                 enc = st->codec;
1809
1810                 avcodec_string(buf, sizeof(buf), enc);
1811                 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
1812                 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
1813                     avg /= enc->frame_size;
1814                 url_fprintf(pb, "<TR><TD>%s <TD> %d <TD> %"PRId64" <TD> %0.1f\n",
1815                              buf, enc->frame_number, fdata->data_count, avg / 1000.0);
1816             }
1817             url_fprintf(pb, "</TABLE>\n");
1818             stream = stream->next_feed;
1819         }
1820     }
1821 #endif
1822
1823     /* connection status */
1824     url_fprintf(pb, "<H2>Connection Status</H2>\n");
1825
1826     url_fprintf(pb, "Number of connections: %d / %d<BR>\n",
1827                  nb_connections, nb_max_connections);
1828
1829     url_fprintf(pb, "Bandwidth in use: %dk / %dk<BR>\n",
1830                  current_bandwidth, max_bandwidth);
1831
1832     url_fprintf(pb, "<TABLE>\n");
1833     url_fprintf(pb, "<TR><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
1834     c1 = first_http_ctx;
1835     i = 0;
1836     while (c1 != NULL) {
1837         int bitrate;
1838         int j;
1839
1840         bitrate = 0;
1841         if (c1->stream) {
1842             for (j = 0; j < c1->stream->nb_streams; j++) {
1843                 if (!c1->stream->feed) {
1844                     bitrate += c1->stream->streams[j]->codec->bit_rate;
1845                 } else {
1846                     if (c1->feed_streams[j] >= 0) {
1847                         bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
1848                     }
1849                 }
1850             }
1851         }
1852
1853         i++;
1854         p = inet_ntoa(c1->from_addr.sin_addr);
1855         url_fprintf(pb, "<TR><TD><B>%d</B><TD>%s%s<TD>%s<TD>%s<TD>%s<td align=right>",
1856                     i,
1857                     c1->stream ? c1->stream->filename : "",
1858                     c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
1859                     p,
1860                     c1->protocol,
1861                     http_state[c1->state]);
1862         fmt_bytecount(pb, bitrate);
1863         url_fprintf(pb, "<td align=right>");
1864         fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
1865         url_fprintf(pb, "<td align=right>");
1866         fmt_bytecount(pb, c1->data_count);
1867         url_fprintf(pb, "\n");
1868         c1 = c1->next;
1869     }
1870     url_fprintf(pb, "</TABLE>\n");
1871
1872     /* date */
1873     ti = time(NULL);
1874     p = ctime(&ti);
1875     url_fprintf(pb, "<HR size=1 noshade>Generated at %s", p);
1876     url_fprintf(pb, "</BODY>\n</HTML>\n");
1877
1878     len = url_close_dyn_buf(pb, &c->pb_buffer);
1879     c->buffer_ptr = c->pb_buffer;
1880     c->buffer_end = c->pb_buffer + len;
1881 }
1882
1883 /* check if the parser needs to be opened for stream i */
1884 static void open_parser(AVFormatContext *s, int i)
1885 {
1886     AVStream *st = s->streams[i];
1887     AVCodec *codec;
1888
1889     if (!st->codec->codec) {
1890         codec = avcodec_find_decoder(st->codec->codec_id);
1891         if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
1892             st->codec->parse_only = 1;
1893             if (avcodec_open(st->codec, codec) < 0) {
1894                 st->codec->parse_only = 0;
1895             }
1896         }
1897     }
1898 }
1899
1900 static int open_input_stream(HTTPContext *c, const char *info)
1901 {
1902     char buf[128];
1903     char input_filename[1024];
1904     AVFormatContext *s;
1905     int buf_size, i;
1906     int64_t stream_pos;
1907
1908     /* find file name */
1909     if (c->stream->feed) {
1910         strcpy(input_filename, c->stream->feed->feed_filename);
1911         buf_size = FFM_PACKET_SIZE;
1912         /* compute position (absolute time) */
1913         if (find_info_tag(buf, sizeof(buf), "date", info)) {
1914             stream_pos = parse_date(buf, 0);
1915         } else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
1916             int prebuffer = strtol(buf, 0, 10);
1917             stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
1918         } else {
1919             stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
1920         }
1921     } else {
1922         strcpy(input_filename, c->stream->feed_filename);
1923         buf_size = 0;
1924         /* compute position (relative time) */
1925         if (find_info_tag(buf, sizeof(buf), "date", info)) {
1926             stream_pos = parse_date(buf, 1);
1927         } else {
1928             stream_pos = 0;
1929         }
1930     }
1931     if (input_filename[0] == '\0')
1932         return -1;
1933
1934 #if 0
1935     { time_t when = stream_pos / 1000000;
1936     http_log("Stream pos = %"PRId64", time=%s", stream_pos, ctime(&when));
1937     }
1938 #endif
1939
1940     /* open stream */
1941     if (av_open_input_file(&s, input_filename, c->stream->ifmt,
1942                            buf_size, c->stream->ap_in) < 0) {
1943         http_log("%s not found", input_filename);
1944         return -1;
1945     }
1946     c->fmt_in = s;
1947
1948     /* open each parser */
1949     for(i=0;i<s->nb_streams;i++)
1950         open_parser(s, i);
1951
1952     /* choose stream as clock source (we favorize video stream if
1953        present) for packet sending */
1954     c->pts_stream_index = 0;
1955     for(i=0;i<c->stream->nb_streams;i++) {
1956         if (c->pts_stream_index == 0 &&
1957             c->stream->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
1958             c->pts_stream_index = i;
1959         }
1960     }
1961
1962 #if 1
1963     if (c->fmt_in->iformat->read_seek) {
1964         c->fmt_in->iformat->read_seek(c->fmt_in, 0, stream_pos, 0);
1965     }
1966 #endif
1967     /* set the start time (needed for maxtime and RTP packet timing) */
1968     c->start_time = cur_time;
1969     c->first_pts = AV_NOPTS_VALUE;
1970     return 0;
1971 }
1972
1973 /* return the server clock (in us) */
1974 static int64_t get_server_clock(HTTPContext *c)
1975 {
1976     /* compute current pts value from system time */
1977     return (cur_time - c->start_time) * 1000;
1978 }
1979
1980 /* return the estimated time at which the current packet must be sent
1981    (in us) */
1982 static int64_t get_packet_send_clock(HTTPContext *c)
1983 {
1984     int bytes_left, bytes_sent, frame_bytes;
1985
1986     frame_bytes = c->cur_frame_bytes;
1987     if (frame_bytes <= 0) {
1988         return c->cur_pts;
1989     } else {
1990         bytes_left = c->buffer_end - c->buffer_ptr;
1991         bytes_sent = frame_bytes - bytes_left;
1992         return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
1993     }
1994 }
1995
1996
1997 static int http_prepare_data(HTTPContext *c)
1998 {
1999     int i, len, ret;
2000     AVFormatContext *ctx;
2001
2002     av_freep(&c->pb_buffer);
2003     switch(c->state) {
2004     case HTTPSTATE_SEND_DATA_HEADER:
2005         memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2006         av_strlcpy(c->fmt_ctx.author, c->stream->author,
2007                    sizeof(c->fmt_ctx.author));
2008         av_strlcpy(c->fmt_ctx.comment, c->stream->comment,
2009                    sizeof(c->fmt_ctx.comment));
2010         av_strlcpy(c->fmt_ctx.copyright, c->stream->copyright,
2011                    sizeof(c->fmt_ctx.copyright));
2012         av_strlcpy(c->fmt_ctx.title, c->stream->title,
2013                    sizeof(c->fmt_ctx.title));
2014
2015         /* open output stream by using specified codecs */
2016         c->fmt_ctx.oformat = c->stream->fmt;
2017         c->fmt_ctx.nb_streams = c->stream->nb_streams;
2018         for(i=0;i<c->fmt_ctx.nb_streams;i++) {
2019             AVStream *st;
2020             AVStream *src;
2021             st = av_mallocz(sizeof(AVStream));
2022             st->codec= avcodec_alloc_context();
2023             c->fmt_ctx.streams[i] = st;
2024             /* if file or feed, then just take streams from FFStream struct */
2025             if (!c->stream->feed ||
2026                 c->stream->feed == c->stream)
2027                 src = c->stream->streams[i];
2028             else
2029                 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2030
2031             *st = *src;
2032             st->priv_data = 0;
2033             st->codec->frame_number = 0; /* XXX: should be done in
2034                                            AVStream, not in codec */
2035             /* I'm pretty sure that this is not correct...
2036              * However, without it, we crash
2037              */
2038             st->codec->coded_frame = &dummy_frame;
2039         }
2040         c->got_key_frame = 0;
2041
2042         /* prepare header and save header data in a stream */
2043         if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2044             /* XXX: potential leak */
2045             return -1;
2046         }
2047         c->fmt_ctx.pb.is_streamed = 1;
2048
2049         av_set_parameters(&c->fmt_ctx, NULL);
2050         if (av_write_header(&c->fmt_ctx) < 0)
2051             return -1;
2052
2053         len = url_close_dyn_buf(&c->fmt_ctx.pb, &c->pb_buffer);
2054         c->buffer_ptr = c->pb_buffer;
2055         c->buffer_end = c->pb_buffer + len;
2056
2057         c->state = HTTPSTATE_SEND_DATA;
2058         c->last_packet_sent = 0;
2059         break;
2060     case HTTPSTATE_SEND_DATA:
2061         /* find a new packet */
2062         {
2063             AVPacket pkt;
2064
2065             /* read a packet from the input stream */
2066             if (c->stream->feed) {
2067                 ffm_set_write_index(c->fmt_in,
2068                                     c->stream->feed->feed_write_index,
2069                                     c->stream->feed->feed_size);
2070             }
2071
2072             if (c->stream->max_time &&
2073                 c->stream->max_time + c->start_time - cur_time < 0) {
2074                 /* We have timed out */
2075                 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2076             } else {
2077             redo:
2078                 if (av_read_frame(c->fmt_in, &pkt) < 0) {
2079                     if (c->stream->feed && c->stream->feed->feed_opened) {
2080                         /* if coming from feed, it means we reached the end of the
2081                            ffm file, so must wait for more data */
2082                         c->state = HTTPSTATE_WAIT_FEED;
2083                         return 1; /* state changed */
2084                     } else {
2085                         if (c->stream->loop) {
2086                             av_close_input_file(c->fmt_in);
2087                             c->fmt_in = NULL;
2088                             if (open_input_stream(c, "") < 0)
2089                                 goto no_loop;
2090                             goto redo;
2091                         } else {
2092                         no_loop:
2093                             /* must send trailer now because eof or error */
2094                             c->state = HTTPSTATE_SEND_DATA_TRAILER;
2095                         }
2096                     }
2097                 } else {
2098                     /* update first pts if needed */
2099                     if (c->first_pts == AV_NOPTS_VALUE) {
2100                         c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2101                         c->start_time = cur_time;
2102                     }
2103                     /* send it to the appropriate stream */
2104                     if (c->stream->feed) {
2105                         /* if coming from a feed, select the right stream */
2106                         if (c->switch_pending) {
2107                             c->switch_pending = 0;
2108                             for(i=0;i<c->stream->nb_streams;i++) {
2109                                 if (c->switch_feed_streams[i] == pkt.stream_index) {
2110                                     if (pkt.flags & PKT_FLAG_KEY) {
2111                                         do_switch_stream(c, i);
2112                                     }
2113                                 }
2114                                 if (c->switch_feed_streams[i] >= 0) {
2115                                     c->switch_pending = 1;
2116                                 }
2117                             }
2118                         }
2119                         for(i=0;i<c->stream->nb_streams;i++) {
2120                             if (c->feed_streams[i] == pkt.stream_index) {
2121                                 pkt.stream_index = i;
2122                                 if (pkt.flags & PKT_FLAG_KEY) {
2123                                     c->got_key_frame |= 1 << i;
2124                                 }
2125                                 /* See if we have all the key frames, then
2126                                  * we start to send. This logic is not quite
2127                                  * right, but it works for the case of a
2128                                  * single video stream with one or more
2129                                  * audio streams (for which every frame is
2130                                  * typically a key frame).
2131                                  */
2132                                 if (!c->stream->send_on_key ||
2133                                     ((c->got_key_frame + 1) >> c->stream->nb_streams)) {
2134                                     goto send_it;
2135                                 }
2136                             }
2137                         }
2138                     } else {
2139                         AVCodecContext *codec;
2140
2141                     send_it:
2142                         /* specific handling for RTP: we use several
2143                            output stream (one for each RTP
2144                            connection). XXX: need more abstract handling */
2145                         if (c->is_packetized) {
2146                             AVStream *st;
2147                             /* compute send time and duration */
2148                             st = c->fmt_in->streams[pkt.stream_index];
2149                             c->cur_pts = av_rescale_q(pkt.dts, st->time_base, AV_TIME_BASE_Q);
2150                             if (st->start_time != AV_NOPTS_VALUE)
2151                                 c->cur_pts -= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2152                             c->cur_frame_duration = av_rescale_q(pkt.duration, st->time_base, AV_TIME_BASE_Q);
2153 #if 0
2154                             printf("index=%d pts=%0.3f duration=%0.6f\n",
2155                                    pkt.stream_index,
2156                                    (double)c->cur_pts /
2157                                    AV_TIME_BASE,
2158                                    (double)c->cur_frame_duration /
2159                                    AV_TIME_BASE);
2160 #endif
2161                             /* find RTP context */
2162                             c->packet_stream_index = pkt.stream_index;
2163                             ctx = c->rtp_ctx[c->packet_stream_index];
2164                             if(!ctx) {
2165                               av_free_packet(&pkt);
2166                               break;
2167                             }
2168                             codec = ctx->streams[0]->codec;
2169                             /* only one stream per RTP connection */
2170                             pkt.stream_index = 0;
2171                         } else {
2172                             ctx = &c->fmt_ctx;
2173                             /* Fudge here */
2174                             codec = ctx->streams[pkt.stream_index]->codec;
2175                         }
2176
2177                         codec->coded_frame->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);
2178                         if (c->is_packetized) {
2179                             int max_packet_size;
2180                             if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP)
2181                                 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2182                             else
2183                                 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2184                             ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2185                         } else {
2186                             ret = url_open_dyn_buf(&ctx->pb);
2187                         }
2188                         if (ret < 0) {
2189                             /* XXX: potential leak */
2190                             return -1;
2191                         }
2192                         if (pkt.dts != AV_NOPTS_VALUE)
2193                             pkt.dts = av_rescale_q(pkt.dts,
2194                                 c->fmt_in->streams[pkt.stream_index]->time_base,
2195                                 ctx->streams[pkt.stream_index]->time_base);
2196                         if (pkt.pts != AV_NOPTS_VALUE)
2197                             pkt.pts = av_rescale_q(pkt.pts,
2198                                 c->fmt_in->streams[pkt.stream_index]->time_base,
2199                                 ctx->streams[pkt.stream_index]->time_base);
2200                         if (av_write_frame(ctx, &pkt)) {
2201                             c->state = HTTPSTATE_SEND_DATA_TRAILER;
2202                         }
2203
2204                         len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2205                         c->cur_frame_bytes = len;
2206                         c->buffer_ptr = c->pb_buffer;
2207                         c->buffer_end = c->pb_buffer + len;
2208
2209                         codec->frame_number++;
2210                         if (len == 0)
2211                             goto redo;
2212                     }
2213                     av_free_packet(&pkt);
2214                 }
2215             }
2216         }
2217         break;
2218     default:
2219     case HTTPSTATE_SEND_DATA_TRAILER:
2220         /* last packet test ? */
2221         if (c->last_packet_sent || c->is_packetized)
2222             return -1;
2223         ctx = &c->fmt_ctx;
2224         /* prepare header */
2225         if (url_open_dyn_buf(&ctx->pb) < 0) {
2226             /* XXX: potential leak */
2227             return -1;
2228         }
2229         av_write_trailer(ctx);
2230         len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2231         c->buffer_ptr = c->pb_buffer;
2232         c->buffer_end = c->pb_buffer + len;
2233
2234         c->last_packet_sent = 1;
2235         break;
2236     }
2237     return 0;
2238 }
2239
2240 /* should convert the format at the same time */
2241 /* send data starting at c->buffer_ptr to the output connection
2242    (either UDP or TCP connection) */
2243 static int http_send_data(HTTPContext *c)
2244 {
2245     int len, ret;
2246
2247     for(;;) {
2248         if (c->buffer_ptr >= c->buffer_end) {
2249             ret = http_prepare_data(c);
2250             if (ret < 0)
2251                 return -1;
2252             else if (ret != 0) {
2253                 /* state change requested */
2254                 break;
2255             }
2256         } else {
2257             if (c->is_packetized) {
2258                 /* RTP data output */
2259                 len = c->buffer_end - c->buffer_ptr;
2260                 if (len < 4) {
2261                     /* fail safe - should never happen */
2262                 fail1:
2263                     c->buffer_ptr = c->buffer_end;
2264                     return 0;
2265                 }
2266                 len = (c->buffer_ptr[0] << 24) |
2267                     (c->buffer_ptr[1] << 16) |
2268                     (c->buffer_ptr[2] << 8) |
2269                     (c->buffer_ptr[3]);
2270                 if (len > (c->buffer_end - c->buffer_ptr))
2271                     goto fail1;
2272                 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2273                     /* nothing to send yet: we can wait */
2274                     return 0;
2275                 }
2276
2277                 c->data_count += len;
2278                 update_datarate(&c->datarate, c->data_count);
2279                 if (c->stream)
2280                     c->stream->bytes_served += len;
2281
2282                 if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP) {
2283                     /* RTP packets are sent inside the RTSP TCP connection */
2284                     ByteIOContext pb1, *pb = &pb1;
2285                     int interleaved_index, size;
2286                     uint8_t header[4];
2287                     HTTPContext *rtsp_c;
2288
2289                     rtsp_c = c->rtsp_c;
2290                     /* if no RTSP connection left, error */
2291                     if (!rtsp_c)
2292                         return -1;
2293                     /* if already sending something, then wait. */
2294                     if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST) {
2295                         break;
2296                     }
2297                     if (url_open_dyn_buf(pb) < 0)
2298                         goto fail1;
2299                     interleaved_index = c->packet_stream_index * 2;
2300                     /* RTCP packets are sent at odd indexes */
2301                     if (c->buffer_ptr[1] == 200)
2302                         interleaved_index++;
2303                     /* write RTSP TCP header */
2304                     header[0] = '$';
2305                     header[1] = interleaved_index;
2306                     header[2] = len >> 8;
2307                     header[3] = len;
2308                     put_buffer(pb, header, 4);
2309                     /* write RTP packet data */
2310                     c->buffer_ptr += 4;
2311                     put_buffer(pb, c->buffer_ptr, len);
2312                     size = url_close_dyn_buf(pb, &c->packet_buffer);
2313                     /* prepare asynchronous TCP sending */
2314                     rtsp_c->packet_buffer_ptr = c->packet_buffer;
2315                     rtsp_c->packet_buffer_end = c->packet_buffer + size;
2316                     c->buffer_ptr += len;
2317
2318                     /* send everything we can NOW */
2319                     len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2320                                 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2321                     if (len > 0) {
2322                         rtsp_c->packet_buffer_ptr += len;
2323                     }
2324                     if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2325                         /* if we could not send all the data, we will
2326                            send it later, so a new state is needed to
2327                            "lock" the RTSP TCP connection */
2328                         rtsp_c->state = RTSPSTATE_SEND_PACKET;
2329                         break;
2330                     } else {
2331                         /* all data has been sent */
2332                         av_freep(&c->packet_buffer);
2333                     }
2334                 } else {
2335                     /* send RTP packet directly in UDP */
2336                     c->buffer_ptr += 4;
2337                     url_write(c->rtp_handles[c->packet_stream_index],
2338                               c->buffer_ptr, len);
2339                     c->buffer_ptr += len;
2340                     /* here we continue as we can send several packets per 10 ms slot */
2341                 }
2342             } else {
2343                 /* TCP data output */
2344                 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2345                 if (len < 0) {
2346                     if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2347                         ff_neterrno() != FF_NETERROR(EINTR)) {
2348                         /* error : close connection */
2349                         return -1;
2350                     } else {
2351                         return 0;
2352                     }
2353                 } else {
2354                     c->buffer_ptr += len;
2355                 }
2356                 c->data_count += len;
2357                 update_datarate(&c->datarate, c->data_count);
2358                 if (c->stream)
2359                     c->stream->bytes_served += len;
2360                 break;
2361             }
2362         }
2363     } /* for(;;) */
2364     return 0;
2365 }
2366
2367 static int http_start_receive_data(HTTPContext *c)
2368 {
2369     int fd;
2370
2371     if (c->stream->feed_opened)
2372         return -1;
2373
2374     /* Don't permit writing to this one */
2375     if (c->stream->readonly)
2376         return -1;
2377
2378     /* open feed */
2379     fd = open(c->stream->feed_filename, O_RDWR);
2380     if (fd < 0)
2381         return -1;
2382     c->feed_fd = fd;
2383
2384     c->stream->feed_write_index = ffm_read_write_index(fd);
2385     c->stream->feed_size = lseek(fd, 0, SEEK_END);
2386     lseek(fd, 0, SEEK_SET);
2387
2388     /* init buffer input */
2389     c->buffer_ptr = c->buffer;
2390     c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2391     c->stream->feed_opened = 1;
2392     return 0;
2393 }
2394
2395 static int http_receive_data(HTTPContext *c)
2396 {
2397     HTTPContext *c1;
2398
2399     if (c->buffer_end > c->buffer_ptr) {
2400         int len;
2401
2402         len = recv(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2403         if (len < 0) {
2404             if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2405                 ff_neterrno() != FF_NETERROR(EINTR)) {
2406                 /* error : close connection */
2407                 goto fail;
2408             }
2409         } else if (len == 0) {
2410             /* end of connection : close it */
2411             goto fail;
2412         } else {
2413             c->buffer_ptr += len;
2414             c->data_count += len;
2415             update_datarate(&c->datarate, c->data_count);
2416         }
2417     }
2418
2419     if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2420         if (c->buffer[0] != 'f' ||
2421             c->buffer[1] != 'm') {
2422             http_log("Feed stream has become desynchronized -- disconnecting\n");
2423             goto fail;
2424         }
2425     }
2426
2427     if (c->buffer_ptr >= c->buffer_end) {
2428         FFStream *feed = c->stream;
2429         /* a packet has been received : write it in the store, except
2430            if header */
2431         if (c->data_count > FFM_PACKET_SIZE) {
2432
2433             //            printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2434             /* XXX: use llseek or url_seek */
2435             lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2436             write(c->feed_fd, c->buffer, FFM_PACKET_SIZE);
2437
2438             feed->feed_write_index += FFM_PACKET_SIZE;
2439             /* update file size */
2440             if (feed->feed_write_index > c->stream->feed_size)
2441                 feed->feed_size = feed->feed_write_index;
2442
2443             /* handle wrap around if max file size reached */
2444             if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2445                 feed->feed_write_index = FFM_PACKET_SIZE;
2446
2447             /* write index */
2448             ffm_write_write_index(c->feed_fd, feed->feed_write_index);
2449
2450             /* wake up any waiting connections */
2451             for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2452                 if (c1->state == HTTPSTATE_WAIT_FEED &&
2453                     c1->stream->feed == c->stream->feed) {
2454                     c1->state = HTTPSTATE_SEND_DATA;
2455                 }
2456             }
2457         } else {
2458             /* We have a header in our hands that contains useful data */
2459             AVFormatContext s;
2460             AVInputFormat *fmt_in;
2461             ByteIOContext *pb = &s.pb;
2462             int i;
2463
2464             memset(&s, 0, sizeof(s));
2465
2466             url_open_buf(pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
2467             pb->buf_end = c->buffer_end;        /* ?? */
2468             pb->is_streamed = 1;
2469
2470             /* use feed output format name to find corresponding input format */
2471             fmt_in = av_find_input_format(feed->fmt->name);
2472             if (!fmt_in)
2473                 goto fail;
2474
2475             if (fmt_in->priv_data_size > 0) {
2476                 s.priv_data = av_mallocz(fmt_in->priv_data_size);
2477                 if (!s.priv_data)
2478                     goto fail;
2479             } else
2480                 s.priv_data = NULL;
2481
2482             if (fmt_in->read_header(&s, 0) < 0) {
2483                 av_freep(&s.priv_data);
2484                 goto fail;
2485             }
2486
2487             /* Now we have the actual streams */
2488             if (s.nb_streams != feed->nb_streams) {
2489                 av_freep(&s.priv_data);
2490                 goto fail;
2491             }
2492             for (i = 0; i < s.nb_streams; i++) {
2493                 memcpy(feed->streams[i]->codec,
2494                        s.streams[i]->codec, sizeof(AVCodecContext));
2495             }
2496             av_freep(&s.priv_data);
2497         }
2498         c->buffer_ptr = c->buffer;
2499     }
2500
2501     return 0;
2502  fail:
2503     c->stream->feed_opened = 0;
2504     close(c->feed_fd);
2505     return -1;
2506 }
2507
2508 /********************************************************************/
2509 /* RTSP handling */
2510
2511 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2512 {
2513     const char *str;
2514     time_t ti;
2515     char *p;
2516     char buf2[32];
2517
2518     switch(error_number) {
2519     case RTSP_STATUS_OK:
2520         str = "OK";
2521         break;
2522     case RTSP_STATUS_METHOD:
2523         str = "Method Not Allowed";
2524         break;
2525     case RTSP_STATUS_BANDWIDTH:
2526         str = "Not Enough Bandwidth";
2527         break;
2528     case RTSP_STATUS_SESSION:
2529         str = "Session Not Found";
2530         break;
2531     case RTSP_STATUS_STATE:
2532         str = "Method Not Valid in This State";
2533         break;
2534     case RTSP_STATUS_AGGREGATE:
2535         str = "Aggregate operation not allowed";
2536         break;
2537     case RTSP_STATUS_ONLY_AGGREGATE:
2538         str = "Only aggregate operation allowed";
2539         break;
2540     case RTSP_STATUS_TRANSPORT:
2541         str = "Unsupported transport";
2542         break;
2543     case RTSP_STATUS_INTERNAL:
2544         str = "Internal Server Error";
2545         break;
2546     case RTSP_STATUS_SERVICE:
2547         str = "Service Unavailable";
2548         break;
2549     case RTSP_STATUS_VERSION:
2550         str = "RTSP Version not supported";
2551         break;
2552     default:
2553         str = "Unknown Error";
2554         break;
2555     }
2556
2557     url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2558     url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2559
2560     /* output GMT time */
2561     ti = time(NULL);
2562     p = ctime(&ti);
2563     strcpy(buf2, p);
2564     p = buf2 + strlen(p) - 1;
2565     if (*p == '\n')
2566         *p = '\0';
2567     url_fprintf(c->pb, "Date: %s GMT\r\n", buf2);
2568 }
2569
2570 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2571 {
2572     rtsp_reply_header(c, error_number);
2573     url_fprintf(c->pb, "\r\n");
2574 }
2575
2576 static int rtsp_parse_request(HTTPContext *c)
2577 {
2578     const char *p, *p1, *p2;
2579     char cmd[32];
2580     char url[1024];
2581     char protocol[32];
2582     char line[1024];
2583     ByteIOContext pb1;
2584     int len;
2585     RTSPHeader header1, *header = &header1;
2586
2587     c->buffer_ptr[0] = '\0';
2588     p = c->buffer;
2589
2590     get_word(cmd, sizeof(cmd), &p);
2591     get_word(url, sizeof(url), &p);
2592     get_word(protocol, sizeof(protocol), &p);
2593
2594     av_strlcpy(c->method, cmd, sizeof(c->method));
2595     av_strlcpy(c->url, url, sizeof(c->url));
2596     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2597
2598     c->pb = &pb1;
2599     if (url_open_dyn_buf(c->pb) < 0) {
2600         /* XXX: cannot do more */
2601         c->pb = NULL; /* safety */
2602         return -1;
2603     }
2604
2605     /* check version name */
2606     if (strcmp(protocol, "RTSP/1.0") != 0) {
2607         rtsp_reply_error(c, RTSP_STATUS_VERSION);
2608         goto the_end;
2609     }
2610
2611     /* parse each header line */
2612     memset(header, 0, sizeof(RTSPHeader));
2613     /* skip to next line */
2614     while (*p != '\n' && *p != '\0')
2615         p++;
2616     if (*p == '\n')
2617         p++;
2618     while (*p != '\0') {
2619         p1 = strchr(p, '\n');
2620         if (!p1)
2621             break;
2622         p2 = p1;
2623         if (p2 > p && p2[-1] == '\r')
2624             p2--;
2625         /* skip empty line */
2626         if (p2 == p)
2627             break;
2628         len = p2 - p;
2629         if (len > sizeof(line) - 1)
2630             len = sizeof(line) - 1;
2631         memcpy(line, p, len);
2632         line[len] = '\0';
2633         rtsp_parse_line(header, line);
2634         p = p1 + 1;
2635     }
2636
2637     /* handle sequence number */
2638     c->seq = header->seq;
2639
2640     if (!strcmp(cmd, "DESCRIBE")) {
2641         rtsp_cmd_describe(c, url);
2642     } else if (!strcmp(cmd, "OPTIONS")) {
2643         rtsp_cmd_options(c, url);
2644     } else if (!strcmp(cmd, "SETUP")) {
2645         rtsp_cmd_setup(c, url, header);
2646     } else if (!strcmp(cmd, "PLAY")) {
2647         rtsp_cmd_play(c, url, header);
2648     } else if (!strcmp(cmd, "PAUSE")) {
2649         rtsp_cmd_pause(c, url, header);
2650     } else if (!strcmp(cmd, "TEARDOWN")) {
2651         rtsp_cmd_teardown(c, url, header);
2652     } else {
2653         rtsp_reply_error(c, RTSP_STATUS_METHOD);
2654     }
2655  the_end:
2656     len = url_close_dyn_buf(c->pb, &c->pb_buffer);
2657     c->pb = NULL; /* safety */
2658     if (len < 0) {
2659         /* XXX: cannot do more */
2660         return -1;
2661     }
2662     c->buffer_ptr = c->pb_buffer;
2663     c->buffer_end = c->pb_buffer + len;
2664     c->state = RTSPSTATE_SEND_REPLY;
2665     return 0;
2666 }
2667
2668 /* XXX: move that to rtsp.c, but would need to replace FFStream by
2669    AVFormatContext */
2670 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2671                                    struct in_addr my_ip)
2672 {
2673     ByteIOContext pb1, *pb = &pb1;
2674     int i, payload_type, port, private_payload_type, j;
2675     const char *ipstr, *title, *mediatype;
2676     AVStream *st;
2677
2678     if (url_open_dyn_buf(pb) < 0)
2679         return -1;
2680
2681     /* general media info */
2682
2683     url_fprintf(pb, "v=0\n");
2684     ipstr = inet_ntoa(my_ip);
2685     url_fprintf(pb, "o=- 0 0 IN IP4 %s\n", ipstr);
2686     title = stream->title;
2687     if (title[0] == '\0')
2688         title = "No Title";
2689     url_fprintf(pb, "s=%s\n", title);
2690     if (stream->comment[0] != '\0')
2691         url_fprintf(pb, "i=%s\n", stream->comment);
2692     if (stream->is_multicast) {
2693         url_fprintf(pb, "c=IN IP4 %s\n", inet_ntoa(stream->multicast_ip));
2694     }
2695     /* for each stream, we output the necessary info */
2696     private_payload_type = RTP_PT_PRIVATE;
2697     for(i = 0; i < stream->nb_streams; i++) {
2698         st = stream->streams[i];
2699         if (st->codec->codec_id == CODEC_ID_MPEG2TS) {
2700             mediatype = "video";
2701         } else {
2702             switch(st->codec->codec_type) {
2703             case CODEC_TYPE_AUDIO:
2704                 mediatype = "audio";
2705                 break;
2706             case CODEC_TYPE_VIDEO:
2707                 mediatype = "video";
2708                 break;
2709             default:
2710                 mediatype = "application";
2711                 break;
2712             }
2713         }
2714         /* NOTE: the port indication is not correct in case of
2715            unicast. It is not an issue because RTSP gives it */
2716         payload_type = rtp_get_payload_type(st->codec);
2717         if (payload_type < 0)
2718             payload_type = private_payload_type++;
2719         if (stream->is_multicast) {
2720             port = stream->multicast_port + 2 * i;
2721         } else {
2722             port = 0;
2723         }
2724         url_fprintf(pb, "m=%s %d RTP/AVP %d\n",
2725                     mediatype, port, payload_type);
2726         if (payload_type >= RTP_PT_PRIVATE) {
2727             /* for private payload type, we need to give more info */
2728             switch(st->codec->codec_id) {
2729             case CODEC_ID_MPEG4:
2730                 {
2731                     uint8_t *data;
2732                     url_fprintf(pb, "a=rtpmap:%d MP4V-ES/%d\n",
2733                                 payload_type, 90000);
2734                     /* we must also add the mpeg4 header */
2735                     data = st->codec->extradata;
2736                     if (data) {
2737                         url_fprintf(pb, "a=fmtp:%d config=", payload_type);
2738                         for(j=0;j<st->codec->extradata_size;j++) {
2739                             url_fprintf(pb, "%02x", data[j]);
2740                         }
2741                         url_fprintf(pb, "\n");
2742                     }
2743                 }
2744                 break;
2745             default:
2746                 /* XXX: add other codecs ? */
2747                 goto fail;
2748             }
2749         }
2750         url_fprintf(pb, "a=control:streamid=%d\n", i);
2751     }
2752     return url_close_dyn_buf(pb, pbuffer);
2753  fail:
2754     url_close_dyn_buf(pb, pbuffer);
2755     av_free(*pbuffer);
2756     return -1;
2757 }
2758
2759 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2760 {
2761 //    rtsp_reply_header(c, RTSP_STATUS_OK);
2762     url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2763     url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2764     url_fprintf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2765     url_fprintf(c->pb, "\r\n");
2766 }
2767
2768 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2769 {
2770     FFStream *stream;
2771     char path1[1024];
2772     const char *path;
2773     uint8_t *content;
2774     int content_length, len;
2775     struct sockaddr_in my_addr;
2776
2777     /* find which url is asked */
2778     url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2779     path = path1;
2780     if (*path == '/')
2781         path++;
2782
2783     for(stream = first_stream; stream != NULL; stream = stream->next) {
2784         if (!stream->is_feed && stream->fmt == &rtp_muxer &&
2785             !strcmp(path, stream->filename)) {
2786             goto found;
2787         }
2788     }
2789     /* no stream found */
2790     rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2791     return;
2792
2793  found:
2794     /* prepare the media description in sdp format */
2795
2796     /* get the host IP */
2797     len = sizeof(my_addr);
2798     getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2799     content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2800     if (content_length < 0) {
2801         rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2802         return;
2803     }
2804     rtsp_reply_header(c, RTSP_STATUS_OK);
2805     url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
2806     url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
2807     url_fprintf(c->pb, "\r\n");
2808     put_buffer(c->pb, content, content_length);
2809 }
2810
2811 static HTTPContext *find_rtp_session(const char *session_id)
2812 {
2813     HTTPContext *c;
2814
2815     if (session_id[0] == '\0')
2816         return NULL;
2817
2818     for(c = first_http_ctx; c != NULL; c = c->next) {
2819         if (!strcmp(c->session_id, session_id))
2820             return c;
2821     }
2822     return NULL;
2823 }
2824
2825 static RTSPTransportField *find_transport(RTSPHeader *h, enum RTSPProtocol protocol)
2826 {
2827     RTSPTransportField *th;
2828     int i;
2829
2830     for(i=0;i<h->nb_transports;i++) {
2831         th = &h->transports[i];
2832         if (th->protocol == protocol)
2833             return th;
2834     }
2835     return NULL;
2836 }
2837
2838 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2839                            RTSPHeader *h)
2840 {
2841     FFStream *stream;
2842     int stream_index, port;
2843     char buf[1024];
2844     char path1[1024];
2845     const char *path;
2846     HTTPContext *rtp_c;
2847     RTSPTransportField *th;
2848     struct sockaddr_in dest_addr;
2849     RTSPActionServerSetup setup;
2850
2851     /* find which url is asked */
2852     url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2853     path = path1;
2854     if (*path == '/')
2855         path++;
2856
2857     /* now check each stream */
2858     for(stream = first_stream; stream != NULL; stream = stream->next) {
2859         if (!stream->is_feed && stream->fmt == &rtp_muxer) {
2860             /* accept aggregate filenames only if single stream */
2861             if (!strcmp(path, stream->filename)) {
2862                 if (stream->nb_streams != 1) {
2863                     rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2864                     return;
2865                 }
2866                 stream_index = 0;
2867                 goto found;
2868             }
2869
2870             for(stream_index = 0; stream_index < stream->nb_streams;
2871                 stream_index++) {
2872                 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2873                          stream->filename, stream_index);
2874                 if (!strcmp(path, buf))
2875                     goto found;
2876             }
2877         }
2878     }
2879     /* no stream found */
2880     rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2881     return;
2882  found:
2883
2884     /* generate session id if needed */
2885     if (h->session_id[0] == '\0') {
2886         snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
2887                  av_random(&random_state), av_random(&random_state));
2888     }
2889
2890     /* find rtp session, and create it if none found */
2891     rtp_c = find_rtp_session(h->session_id);
2892     if (!rtp_c) {
2893         /* always prefer UDP */
2894         th = find_transport(h, RTSP_PROTOCOL_RTP_UDP);
2895         if (!th) {
2896             th = find_transport(h, RTSP_PROTOCOL_RTP_TCP);
2897             if (!th) {
2898                 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2899                 return;
2900             }
2901         }
2902
2903         rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
2904                                    th->protocol);
2905         if (!rtp_c) {
2906             rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
2907             return;
2908         }
2909
2910         /* open input stream */
2911         if (open_input_stream(rtp_c, "") < 0) {
2912             rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2913             return;
2914         }
2915     }
2916
2917     /* test if stream is OK (test needed because several SETUP needs
2918        to be done for a given file) */
2919     if (rtp_c->stream != stream) {
2920         rtsp_reply_error(c, RTSP_STATUS_SERVICE);
2921         return;
2922     }
2923
2924     /* test if stream is already set up */
2925     if (rtp_c->rtp_ctx[stream_index]) {
2926         rtsp_reply_error(c, RTSP_STATUS_STATE);
2927         return;
2928     }
2929
2930     /* check transport */
2931     th = find_transport(h, rtp_c->rtp_protocol);
2932     if (!th || (th->protocol == RTSP_PROTOCOL_RTP_UDP &&
2933                 th->client_port_min <= 0)) {
2934         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2935         return;
2936     }
2937
2938     /* setup default options */
2939     setup.transport_option[0] = '\0';
2940     dest_addr = rtp_c->from_addr;
2941     dest_addr.sin_port = htons(th->client_port_min);
2942
2943     /* setup stream */
2944     if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
2945         rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2946         return;
2947     }
2948
2949     /* now everything is OK, so we can send the connection parameters */
2950     rtsp_reply_header(c, RTSP_STATUS_OK);
2951     /* session ID */
2952     url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2953
2954     switch(rtp_c->rtp_protocol) {
2955     case RTSP_PROTOCOL_RTP_UDP:
2956         port = rtp_get_local_port(rtp_c->rtp_handles[stream_index]);
2957         url_fprintf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
2958                     "client_port=%d-%d;server_port=%d-%d",
2959                     th->client_port_min, th->client_port_min + 1,
2960                     port, port + 1);
2961         break;
2962     case RTSP_PROTOCOL_RTP_TCP:
2963         url_fprintf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
2964                     stream_index * 2, stream_index * 2 + 1);
2965         break;
2966     default:
2967         break;
2968     }
2969     if (setup.transport_option[0] != '\0') {
2970         url_fprintf(c->pb, ";%s", setup.transport_option);
2971     }
2972     url_fprintf(c->pb, "\r\n");
2973
2974
2975     url_fprintf(c->pb, "\r\n");
2976 }
2977
2978
2979 /* find an rtp connection by using the session ID. Check consistency
2980    with filename */
2981 static HTTPContext *find_rtp_session_with_url(const char *url,
2982                                               const char *session_id)
2983 {
2984     HTTPContext *rtp_c;
2985     char path1[1024];
2986     const char *path;
2987     char buf[1024];
2988     int s;
2989
2990     rtp_c = find_rtp_session(session_id);
2991     if (!rtp_c)
2992         return NULL;
2993
2994     /* find which url is asked */
2995     url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2996     path = path1;
2997     if (*path == '/')
2998         path++;
2999     if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3000     for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3001       snprintf(buf, sizeof(buf), "%s/streamid=%d",
3002         rtp_c->stream->filename, s);
3003       if(!strncmp(path, buf, sizeof(buf))) {
3004     // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3005         return rtp_c;
3006       }
3007     }
3008     return NULL;
3009 }
3010
3011 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h)
3012 {
3013     HTTPContext *rtp_c;
3014
3015     rtp_c = find_rtp_session_with_url(url, h->session_id);
3016     if (!rtp_c) {
3017         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3018         return;
3019     }
3020
3021     if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3022         rtp_c->state != HTTPSTATE_WAIT_FEED &&
3023         rtp_c->state != HTTPSTATE_READY) {
3024         rtsp_reply_error(c, RTSP_STATUS_STATE);
3025         return;
3026     }
3027
3028 #if 0
3029     /* XXX: seek in stream */
3030     if (h->range_start != AV_NOPTS_VALUE) {
3031         printf("range_start=%0.3f\n", (double)h->range_start / AV_TIME_BASE);
3032         av_seek_frame(rtp_c->fmt_in, -1, h->range_start);
3033     }
3034 #endif
3035
3036     rtp_c->state = HTTPSTATE_SEND_DATA;
3037
3038     /* now everything is OK, so we can send the connection parameters */
3039     rtsp_reply_header(c, RTSP_STATUS_OK);
3040     /* session ID */
3041     url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3042     url_fprintf(c->pb, "\r\n");
3043 }
3044
3045 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h)
3046 {
3047     HTTPContext *rtp_c;
3048
3049     rtp_c = find_rtp_session_with_url(url, h->session_id);
3050     if (!rtp_c) {
3051         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3052         return;
3053     }
3054
3055     if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3056         rtp_c->state != HTTPSTATE_WAIT_FEED) {
3057         rtsp_reply_error(c, RTSP_STATUS_STATE);
3058         return;
3059     }
3060
3061     rtp_c->state = HTTPSTATE_READY;
3062     rtp_c->first_pts = AV_NOPTS_VALUE;
3063     /* now everything is OK, so we can send the connection parameters */
3064     rtsp_reply_header(c, RTSP_STATUS_OK);
3065     /* session ID */
3066     url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3067     url_fprintf(c->pb, "\r\n");
3068 }
3069
3070 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h)
3071 {
3072     HTTPContext *rtp_c;
3073     char session_id[32];
3074
3075     rtp_c = find_rtp_session_with_url(url, h->session_id);
3076     if (!rtp_c) {
3077         rtsp_reply_error(c, RTSP_STATUS_SESSION);
3078         return;
3079     }
3080
3081     av_strlcpy(session_id, rtp_c->session_id, sizeof(session_id));
3082
3083     /* abort the session */
3084     close_connection(rtp_c);
3085
3086     /* now everything is OK, so we can send the connection parameters */
3087     rtsp_reply_header(c, RTSP_STATUS_OK);
3088     /* session ID */
3089     url_fprintf(c->pb, "Session: %s\r\n", session_id);
3090     url_fprintf(c->pb, "\r\n");
3091 }
3092
3093
3094 /********************************************************************/
3095 /* RTP handling */
3096
3097 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3098                                        FFStream *stream, const char *session_id,
3099                                        enum RTSPProtocol rtp_protocol)
3100 {
3101     HTTPContext *c = NULL;
3102     const char *proto_str;
3103
3104     /* XXX: should output a warning page when coming
3105        close to the connection limit */
3106     if (nb_connections >= nb_max_connections)
3107         goto fail;
3108
3109     /* add a new connection */
3110     c = av_mallocz(sizeof(HTTPContext));
3111     if (!c)
3112         goto fail;
3113
3114     c->fd = -1;
3115     c->poll_entry = NULL;
3116     c->from_addr = *from_addr;
3117     c->buffer_size = IOBUFFER_INIT_SIZE;
3118     c->buffer = av_malloc(c->buffer_size);
3119     if (!c->buffer)
3120         goto fail;
3121     nb_connections++;
3122     c->stream = stream;
3123     av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3124     c->state = HTTPSTATE_READY;
3125     c->is_packetized = 1;
3126     c->rtp_protocol = rtp_protocol;
3127
3128     /* protocol is shown in statistics */
3129     switch(c->rtp_protocol) {
3130     case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3131         proto_str = "MCAST";
3132         break;
3133     case RTSP_PROTOCOL_RTP_UDP:
3134         proto_str = "UDP";
3135         break;
3136     case RTSP_PROTOCOL_RTP_TCP:
3137         proto_str = "TCP";
3138         break;
3139     default:
3140         proto_str = "???";
3141         break;
3142     }
3143     av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3144     av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3145
3146     current_bandwidth += stream->bandwidth;
3147
3148     c->next = first_http_ctx;
3149     first_http_ctx = c;
3150     return c;
3151
3152  fail:
3153     if (c) {
3154         av_free(c->buffer);
3155         av_free(c);
3156     }
3157     return NULL;
3158 }
3159
3160 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3161    command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3162    used. */
3163 static int rtp_new_av_stream(HTTPContext *c,
3164                              int stream_index, struct sockaddr_in *dest_addr,
3165                              HTTPContext *rtsp_c)
3166 {
3167     AVFormatContext *ctx;
3168     AVStream *st;
3169     char *ipaddr;
3170     URLContext *h;
3171     uint8_t *dummy_buf;
3172     char buf2[32];
3173     int max_packet_size;
3174
3175     /* now we can open the relevant output stream */
3176     ctx = av_alloc_format_context();
3177     if (!ctx)
3178         return -1;
3179     ctx->oformat = &rtp_muxer;
3180
3181     st = av_mallocz(sizeof(AVStream));
3182     if (!st)
3183         goto fail;
3184     st->codec= avcodec_alloc_context();
3185     ctx->nb_streams = 1;
3186     ctx->streams[0] = st;
3187
3188     if (!c->stream->feed ||
3189         c->stream->feed == c->stream) {
3190         memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3191     } else {
3192         memcpy(st,
3193                c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3194                sizeof(AVStream));
3195     }
3196     st->priv_data = NULL;
3197
3198     /* build destination RTP address */
3199     ipaddr = inet_ntoa(dest_addr->sin_addr);
3200
3201     switch(c->rtp_protocol) {
3202     case RTSP_PROTOCOL_RTP_UDP:
3203     case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3204         /* RTP/UDP case */
3205
3206         /* XXX: also pass as parameter to function ? */
3207         if (c->stream->is_multicast) {
3208             int ttl;
3209             ttl = c->stream->multicast_ttl;
3210             if (!ttl)
3211                 ttl = 16;
3212             snprintf(ctx->filename, sizeof(ctx->filename),
3213                      "rtp://%s:%d?multicast=1&ttl=%d",
3214                      ipaddr, ntohs(dest_addr->sin_port), ttl);
3215         } else {
3216             snprintf(ctx->filename, sizeof(ctx->filename),
3217                      "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3218         }
3219
3220         if (url_open(&h, ctx->filename, URL_WRONLY) < 0)
3221             goto fail;
3222         c->rtp_handles[stream_index] = h;
3223         max_packet_size = url_get_max_packet_size(h);
3224         break;
3225     case RTSP_PROTOCOL_RTP_TCP:
3226         /* RTP/TCP case */
3227         c->rtsp_c = rtsp_c;
3228         max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3229         break;
3230     default:
3231         goto fail;
3232     }
3233
3234     http_log("%s:%d - - [%s] \"PLAY %s/streamid=%d %s\"\n",
3235              ipaddr, ntohs(dest_addr->sin_port),
3236              ctime1(buf2),
3237              c->stream->filename, stream_index, c->protocol);
3238
3239     /* normally, no packets should be output here, but the packet size may be checked */
3240     if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3241         /* XXX: close stream */
3242         goto fail;
3243     }
3244     av_set_parameters(ctx, NULL);
3245     if (av_write_header(ctx) < 0) {
3246     fail:
3247         if (h)
3248             url_close(h);
3249         av_free(ctx);
3250         return -1;
3251     }
3252     url_close_dyn_buf(&ctx->pb, &dummy_buf);
3253     av_free(dummy_buf);
3254
3255     c->rtp_ctx[stream_index] = ctx;
3256     return 0;
3257 }
3258
3259 /********************************************************************/
3260 /* ffserver initialization */
3261
3262 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
3263 {
3264     AVStream *fst;
3265
3266     fst = av_mallocz(sizeof(AVStream));
3267     if (!fst)
3268         return NULL;
3269     fst->codec= avcodec_alloc_context();
3270     fst->priv_data = av_mallocz(sizeof(FeedData));
3271     memcpy(fst->codec, codec, sizeof(AVCodecContext));
3272     fst->codec->coded_frame = &dummy_frame;
3273     fst->index = stream->nb_streams;
3274     av_set_pts_info(fst, 33, 1, 90000);
3275     stream->streams[stream->nb_streams++] = fst;
3276     return fst;
3277 }
3278
3279 /* return the stream number in the feed */
3280 static int add_av_stream(FFStream *feed, AVStream *st)
3281 {
3282     AVStream *fst;
3283     AVCodecContext *av, *av1;
3284     int i;
3285
3286     av = st->codec;
3287     for(i=0;i<feed->nb_streams;i++) {
3288         st = feed->streams[i];
3289         av1 = st->codec;
3290         if (av1->codec_id == av->codec_id &&
3291             av1->codec_type == av->codec_type &&
3292             av1->bit_rate == av->bit_rate) {
3293
3294             switch(av->codec_type) {
3295             case CODEC_TYPE_AUDIO:
3296                 if (av1->channels == av->channels &&
3297                     av1->sample_rate == av->sample_rate)
3298                     goto found;
3299                 break;
3300             case CODEC_TYPE_VIDEO:
3301                 if (av1->width == av->width &&
3302                     av1->height == av->height &&
3303                     av1->time_base.den == av->time_base.den &&
3304                     av1->time_base.num == av->time_base.num &&
3305                     av1->gop_size == av->gop_size)
3306                     goto found;
3307                 break;
3308             default:
3309                 abort();
3310             }
3311         }
3312     }
3313
3314     fst = add_av_stream1(feed, av);
3315     if (!fst)
3316         return -1;
3317     return feed->nb_streams - 1;
3318  found:
3319     return i;
3320 }
3321
3322 static void remove_stream(FFStream *stream)
3323 {
3324     FFStream **ps;
3325     ps = &first_stream;
3326     while (*ps != NULL) {
3327         if (*ps == stream) {
3328             *ps = (*ps)->next;
3329         } else {
3330             ps = &(*ps)->next;
3331         }
3332     }
3333 }
3334
3335 /* specific mpeg4 handling : we extract the raw parameters */
3336 static void extract_mpeg4_header(AVFormatContext *infile)
3337 {
3338     int mpeg4_count, i, size;
3339     AVPacket pkt;
3340     AVStream *st;
3341     const uint8_t *p;
3342
3343     mpeg4_count = 0;
3344     for(i=0;i<infile->nb_streams;i++) {
3345         st = infile->streams[i];
3346         if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3347             st->codec->extradata_size == 0) {
3348             mpeg4_count++;
3349         }
3350     }
3351     if (!mpeg4_count)
3352         return;
3353
3354     printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3355     while (mpeg4_count > 0) {
3356         if (av_read_packet(infile, &pkt) < 0)
3357             break;
3358         st = infile->streams[pkt.stream_index];
3359         if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3360             st->codec->extradata_size == 0) {
3361             av_freep(&st->codec->extradata);
3362             /* fill extradata with the header */
3363             /* XXX: we make hard suppositions here ! */
3364             p = pkt.data;
3365             while (p < pkt.data + pkt.size - 4) {
3366                 /* stop when vop header is found */
3367                 if (p[0] == 0x00 && p[1] == 0x00 &&
3368                     p[2] == 0x01 && p[3] == 0xb6) {
3369                     size = p - pkt.data;
3370                     //                    av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3371                     st->codec->extradata = av_malloc(size);
3372                     st->codec->extradata_size = size;
3373                     memcpy(st->codec->extradata, pkt.data, size);
3374                     break;
3375                 }
3376                 p++;
3377             }
3378             mpeg4_count--;
3379         }
3380         av_free_packet(&pkt);
3381     }
3382 }
3383
3384 /* compute the needed AVStream for each file */
3385 static void build_file_streams(void)
3386 {
3387     FFStream *stream, *stream_next;
3388     AVFormatContext *infile;
3389     int i;
3390
3391     /* gather all streams */
3392     for(stream = first_stream; stream != NULL; stream = stream_next) {
3393         stream_next = stream->next;
3394         if (stream->stream_type == STREAM_TYPE_LIVE &&
3395             !stream->feed) {
3396             /* the stream comes from a file */
3397             /* try to open the file */
3398             /* open stream */
3399             stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
3400             if (stream->fmt == &rtp_muxer) {
3401                 /* specific case : if transport stream output to RTP,
3402                    we use a raw transport stream reader */
3403                 stream->ap_in->mpeg2ts_raw = 1;
3404                 stream->ap_in->mpeg2ts_compute_pcr = 1;
3405             }
3406
3407             if (av_open_input_file(&infile, stream->feed_filename,
3408                                    stream->ifmt, 0, stream->ap_in) < 0) {
3409                 http_log("%s not found", stream->feed_filename);
3410                 /* remove stream (no need to spend more time on it) */
3411             fail:
3412                 remove_stream(stream);
3413             } else {
3414                 /* find all the AVStreams inside and reference them in
3415                    'stream' */
3416                 if (av_find_stream_info(infile) < 0) {
3417                     http_log("Could not find codec parameters from '%s'",
3418                              stream->feed_filename);
3419                     av_close_input_file(infile);
3420                     goto fail;
3421                 }
3422                 extract_mpeg4_header(infile);
3423
3424                 for(i=0;i<infile->nb_streams;i++) {
3425                     add_av_stream1(stream, infile->streams[i]->codec);
3426                 }
3427                 av_close_input_file(infile);
3428             }
3429         }
3430     }
3431 }
3432
3433 /* compute the needed AVStream for each feed */
3434 static void build_feed_streams(void)
3435 {
3436     FFStream *stream, *feed;
3437     int i;
3438
3439     /* gather all streams */
3440     for(stream = first_stream; stream != NULL; stream = stream->next) {
3441         feed = stream->feed;
3442         if (feed) {
3443             if (!stream->is_feed) {
3444                 /* we handle a stream coming from a feed */
3445                 for(i=0;i<stream->nb_streams;i++) {
3446                     stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3447                 }
3448             }
3449         }
3450     }
3451
3452     /* gather all streams */
3453     for(stream = first_stream; stream != NULL; stream = stream->next) {
3454         feed = stream->feed;
3455         if (feed) {
3456             if (stream->is_feed) {
3457                 for(i=0;i<stream->nb_streams;i++) {
3458                     stream->feed_streams[i] = i;
3459                 }
3460             }
3461         }
3462     }
3463
3464     /* create feed files if needed */
3465     for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3466         int fd;
3467
3468         if (url_exist(feed->feed_filename)) {
3469             /* See if it matches */
3470             AVFormatContext *s;
3471             int matches = 0;
3472
3473             if (av_open_input_file(&s, feed->feed_filename, NULL, FFM_PACKET_SIZE, NULL) >= 0) {
3474                 /* Now see if it matches */
3475                 if (s->nb_streams == feed->nb_streams) {
3476                     matches = 1;
3477                     for(i=0;i<s->nb_streams;i++) {
3478                         AVStream *sf, *ss;
3479                         sf = feed->streams[i];
3480                         ss = s->streams[i];
3481
3482                         if (sf->index != ss->index ||
3483                             sf->id != ss->id) {
3484                             printf("Index & Id do not match for stream %d (%s)\n",
3485                                    i, feed->feed_filename);
3486                             matches = 0;
3487                         } else {
3488                             AVCodecContext *ccf, *ccs;
3489
3490                             ccf = sf->codec;
3491                             ccs = ss->codec;
3492 #define CHECK_CODEC(x)  (ccf->x != ccs->x)
3493
3494                             if (CHECK_CODEC(codec) || CHECK_CODEC(codec_type)) {
3495                                 printf("Codecs do not match for stream %d\n", i);
3496                                 matches = 0;
3497                             } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3498                                 printf("Codec bitrates do not match for stream %d\n", i);
3499                                 matches = 0;
3500                             } else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
3501                                 if (CHECK_CODEC(time_base.den) ||
3502                                     CHECK_CODEC(time_base.num) ||
3503                                     CHECK_CODEC(width) ||
3504                                     CHECK_CODEC(height)) {
3505                                     printf("Codec width, height and framerate do not match for stream %d\n", i);
3506                                     matches = 0;
3507                                 }
3508                             } else if (ccf->codec_type == CODEC_TYPE_AUDIO) {
3509                                 if (CHECK_CODEC(sample_rate) ||
3510                                     CHECK_CODEC(channels) ||
3511                                     CHECK_CODEC(frame_size)) {
3512                                     printf("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3513                                     matches = 0;
3514                                 }
3515                             } else {
3516                                 printf("Unknown codec type\n");
3517                                 matches = 0;
3518                             }
3519                         }
3520                         if (!matches) {
3521                             break;
3522                         }
3523                     }
3524                 } else {
3525                     printf("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3526                         feed->feed_filename, s->nb_streams, feed->nb_streams);
3527                 }
3528
3529                 av_close_input_file(s);
3530             } else {
3531                 printf("Deleting feed file '%s' as it appears to be corrupt\n",
3532                         feed->feed_filename);
3533             }
3534             if (!matches) {
3535                 if (feed->readonly) {
3536                     printf("Unable to delete feed file '%s' as it is marked readonly\n",
3537                         feed->feed_filename);
3538                     exit(1);
3539                 }
3540                 unlink(feed->feed_filename);
3541             }
3542         }
3543         if (!url_exist(feed->feed_filename)) {
3544             AVFormatContext s1, *s = &s1;
3545
3546             if (feed->readonly) {
3547                 printf("Unable to create feed file '%s' as it is marked readonly\n",
3548                     feed->feed_filename);
3549                 exit(1);
3550             }
3551
3552             /* only write the header of the ffm file */
3553             if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
3554                 fprintf(stderr, "Could not open output feed file '%s'\n",
3555                         feed->feed_filename);
3556                 exit(1);
3557             }
3558             s->oformat = feed->fmt;
3559             s->nb_streams = feed->nb_streams;
3560             for(i=0;i<s->nb_streams;i++) {
3561                 AVStream *st;
3562                 st = feed->streams[i];
3563                 s->streams[i] = st;
3564             }
3565             av_set_parameters(s, NULL);
3566             if (av_write_header(s) < 0) {
3567                 fprintf(stderr, "Container doesn't supports the required parameters\n");
3568                 exit(1);
3569             }
3570             /* XXX: need better api */
3571             av_freep(&s->priv_data);
3572             url_fclose(&s->pb);
3573         }
3574         /* get feed size and write index */
3575         fd = open(feed->feed_filename, O_RDONLY);
3576         if (fd < 0) {
3577             fprintf(stderr, "Could not open output feed file '%s'\n",
3578                     feed->feed_filename);
3579             exit(1);
3580         }
3581
3582         feed->feed_write_index = ffm_read_write_index(fd);
3583         feed->feed_size = lseek(fd, 0, SEEK_END);
3584         /* ensure that we do not wrap before the end of file */
3585         if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3586             feed->feed_max_size = feed->feed_size;
3587
3588         close(fd);
3589     }
3590 }
3591
3592 /* compute the bandwidth used by each stream */
3593 static void compute_bandwidth(void)
3594 {
3595     int bandwidth, i;
3596     FFStream *stream;
3597
3598     for(stream = first_stream; stream != NULL; stream = stream->next) {
3599         bandwidth = 0;
3600         for(i=0;i<stream->nb_streams;i++) {
3601             AVStream *st = stream->streams[i];
3602             switch(st->codec->codec_type) {
3603             case CODEC_TYPE_AUDIO:
3604             case CODEC_TYPE_VIDEO:
3605                 bandwidth += st->codec->bit_rate;
3606                 break;
3607             default:
3608                 break;
3609             }
3610         }
3611         stream->bandwidth = (bandwidth + 999) / 1000;
3612     }
3613 }
3614
3615 static void get_arg(char *buf, int buf_size, const char **pp)
3616 {
3617     const char *p;
3618     char *q;
3619     int quote;
3620