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