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