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