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