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