ffserver.c

                        c->first_pts = pkt.pts;
                    
                    /* send it to the appropriate stream */
                    if (c->stream->feed) {
                        /* if coming from a feed, select the right stream */
                        if (c->switch_pending) {
                            c->switch_pending = 0;
                            for(i=0;i<c->stream->nb_streams;i++) {
                                if (c->switch_feed_streams[i] == pkt.stream_index) {
                                    if (pkt.flags & PKT_FLAG_KEY) {
                                        do_switch_stream(c, i);
                                    }
                                }
                                if (c->switch_feed_streams[i] >= 0) {
                                    c->switch_pending = 1;
                                }
                            }
                        }
                        for(i=0;i<c->stream->nb_streams;i++) {
                            if (c->feed_streams[i] == pkt.stream_index) {
                                pkt.stream_index = i;
                                if (pkt.flags & PKT_FLAG_KEY) {
                                    c->got_key_frame |= 1 << i;
                                }
                                /* See if we have all the key frames, then 
                                 * we start to send. This logic is not quite
                                 * right, but it works for the case of a 
                                 * single video stream with one or more
                                 * audio streams (for which every frame is 
                                 * typically a key frame). 
                                 */
                                if (!c->stream->send_on_key || 
                                    ((c->got_key_frame + 1) >> c->stream->nb_streams)) {
                                    goto send_it;
                                }
                            }
                        }
                    } else {
                        AVCodecContext *codec;
                        
                    send_it:
                        /* specific handling for RTP: we use several
                           output stream (one for each RTP
                           connection). XXX: need more abstract handling */
                        if (c->is_packetized) {
                            c->packet_stream_index = pkt.stream_index;
                            ctx = c->rtp_ctx[c->packet_stream_index];
                            codec = &ctx->streams[0]->codec;
                        } else {
                            ctx = &c->fmt_ctx;
                            /* Fudge here */
                            codec = &ctx->streams[pkt.stream_index]->codec;
                        }
                        
                        codec->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);
                        
#ifdef PJSG
                        if (codec->codec_type == CODEC_TYPE_AUDIO) {
                            codec->frame_size = (codec->sample_rate * pkt.duration + 500000) / 1000000;
                            /* printf("Calculated size %d, from sr %d, duration %d\n", codec->frame_size, codec->sample_rate, pkt.duration); */
                        }
#endif
                        
                        if (c->is_packetized) {
                            ret = url_open_dyn_packet_buf(&ctx->pb, 
                                                          url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]));
                            c->packet_byte_count = 0;
                            c->packet_start_time_us = av_gettime();
                        } else {
                            ret = url_open_dyn_buf(&ctx->pb);
                        }
                        if (ret < 0) {
                            /* XXX: potential leak */
                            return -1;
                        }
                        if (av_write_packet(ctx, &pkt, pkt.pts)) {
                            c->state = HTTPSTATE_SEND_DATA_TRAILER;
                        }
                        
                        len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
                        c->buffer_ptr = c->pb_buffer;
                        c->buffer_end = c->pb_buffer + len;
                        
                        codec->frame_number++;
                    }
#ifndef AV_READ_FRAME
                    av_free_packet(&pkt);
#endif
                }
            }
        }
        break;
    default:
    case HTTPSTATE_SEND_DATA_TRAILER:
        /* last packet test ? */
        if (c->last_packet_sent || c->is_packetized)
            return -1;
        ctx = &c->fmt_ctx;
        /* prepare header */
        if (url_open_dyn_buf(&ctx->pb) < 0) {
            /* XXX: potential leak */
            return -1;
        }
        av_write_trailer(ctx);
        len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
        c->buffer_ptr = c->pb_buffer;
        c->buffer_end = c->pb_buffer + len;

        c->last_packet_sent = 1;
        break;
    }
    return 0;
}

/* in bit/s */
#define SHORT_TERM_BANDWIDTH 8000000

/* should convert the format at the same time */
static int http_send_data(HTTPContext *c)
{
    int len, ret, dt;
    
    while (c->buffer_ptr >= c->buffer_end) {
        av_freep(&c->pb_buffer);
        ret = http_prepare_data(c);
        if (ret < 0)
            return -1;
        else if (ret == 0) {
            continue;
        } else {
            /* state change requested */
            return 0;
        }
    }

    if (c->buffer_ptr < c->buffer_end) {
        if (c->is_packetized) {
            /* RTP/UDP data output */
            len = c->buffer_end - c->buffer_ptr;
            if (len < 4) {
                /* fail safe - should never happen */
            fail1:
                c->buffer_ptr = c->buffer_end;
                return 0;
            }
            len = (c->buffer_ptr[0] << 24) |
                (c->buffer_ptr[1] << 16) |
                (c->buffer_ptr[2] << 8) |
                (c->buffer_ptr[3]);
            if (len > (c->buffer_end - c->buffer_ptr))
                goto fail1;
            
            /* short term bandwidth limitation */
            dt = av_gettime() - c->packet_start_time_us;
            if (dt < 1)
                dt = 1;

            if ((c->packet_byte_count + len) * (INT64)1000000 >= 
                (SHORT_TERM_BANDWIDTH / 8) * (INT64)dt) {
                /* bandwidth overflow : wait at most one tick and retry */
                c->state = HTTPSTATE_WAIT_SHORT;
                return 0;
            }

            c->buffer_ptr += 4;
            url_write(c->rtp_handles[c->packet_stream_index], 
                      c->buffer_ptr, len);
            c->buffer_ptr += len;
            c->packet_byte_count += len;
        } else {
            /* TCP data output */
            len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
            if (len < 0) {
                if (errno != EAGAIN && errno != EINTR) {
                    /* error : close connection */
                    return -1;
                } else {
                    return 0;
                }
            } else {
                c->buffer_ptr += len;
            }
        }
        c->data_count += len;
        update_datarate(&c->datarate, c->data_count);
        if (c->stream)
            c->stream->bytes_served += len;
    }
    return 0;
}

static int http_start_receive_data(HTTPContext *c)
{
    int fd;

    if (c->stream->feed_opened)
        return -1;

    /* open feed */
    fd = open(c->stream->feed_filename, O_RDWR);
    if (fd < 0)
        return -1;
    c->feed_fd = fd;
    
    c->stream->feed_write_index = ffm_read_write_index(fd);
    c->stream->feed_size = lseek(fd, 0, SEEK_END);
    lseek(fd, 0, SEEK_SET);

    /* init buffer input */
    c->buffer_ptr = c->buffer;
    c->buffer_end = c->buffer + FFM_PACKET_SIZE;
    c->stream->feed_opened = 1;
    return 0;
}
    
static int http_receive_data(HTTPContext *c)
{
    HTTPContext *c1;

    if (c->buffer_end > c->buffer_ptr) {
        int len;

        len = read(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
        if (len < 0) {
            if (errno != EAGAIN && errno != EINTR) {
                /* error : close connection */
                goto fail;
            }
        } else if (len == 0) {
            /* end of connection : close it */
            goto fail;
        } else {
            c->buffer_ptr += len;
            c->data_count += len;
            update_datarate(&c->datarate, c->data_count);
        }
    }

    if (c->buffer_ptr >= c->buffer_end) {
        FFStream *feed = c->stream;
        /* a packet has been received : write it in the store, except
           if header */
        if (c->data_count > FFM_PACKET_SIZE) {
            
            //            printf("writing pos=0x%Lx size=0x%Lx\n", feed->feed_write_index, feed->feed_size);
            /* XXX: use llseek or url_seek */
            lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
            write(c->feed_fd, c->buffer, FFM_PACKET_SIZE);
            
            feed->feed_write_index += FFM_PACKET_SIZE;
            /* update file size */
            if (feed->feed_write_index > c->stream->feed_size)
                feed->feed_size = feed->feed_write_index;

            /* handle wrap around if max file size reached */
            if (feed->feed_write_index >= c->stream->feed_max_size)
                feed->feed_write_index = FFM_PACKET_SIZE;

            /* write index */
            ffm_write_write_index(c->feed_fd, feed->feed_write_index);

            /* wake up any waiting connections */
            for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
                if (c1->state == HTTPSTATE_WAIT_FEED && 
                    c1->stream->feed == c->stream->feed) {
                    c1->state = HTTPSTATE_SEND_DATA;
                }
            }
        } else {
            /* We have a header in our hands that contains useful data */
            AVFormatContext s;
            AVInputFormat *fmt_in;
            ByteIOContext *pb = &s.pb;
            int i;

            memset(&s, 0, sizeof(s));

            url_open_buf(pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
            pb->buf_end = c->buffer_end;        /* ?? */
            pb->is_streamed = 1;

            /* use feed output format name to find corresponding input format */
            fmt_in = av_find_input_format(feed->fmt->name);
            if (!fmt_in)
                goto fail;

            s.priv_data = av_mallocz(fmt_in->priv_data_size);
            if (!s.priv_data)
                goto fail;

            if (fmt_in->read_header(&s, 0) < 0) {
                av_freep(&s.priv_data);
                goto fail;
            }

            /* Now we have the actual streams */
            if (s.nb_streams != feed->nb_streams) {
                av_freep(&s.priv_data);
                goto fail;
            }
            for (i = 0; i < s.nb_streams; i++) {
                memcpy(&feed->streams[i]->codec, 
                       &s.streams[i]->codec, sizeof(AVCodecContext));
            } 
            av_freep(&s.priv_data);
        }
        c->buffer_ptr = c->buffer;
    }

    return 0;
 fail:
    c->stream->feed_opened = 0;
    close(c->feed_fd);
    return -1;
}

/********************************************************************/
/* RTSP handling */

static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
{
    const char *str;
    time_t ti;
    char *p;
    char buf2[32];

    switch(error_number) {
#define DEF(n, c, s) case c: str = s; break; 
#include "rtspcodes.h"
#undef DEF
    default:
        str = "Unknown Error";
        break;
    }
     
    url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
    url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);

    /* output GMT time */
    ti = time(NULL);
    p = ctime(&ti);
    strcpy(buf2, p);
    p = buf2 + strlen(p) - 1;
    if (*p == '\n')
        *p = '\0';
    url_fprintf(c->pb, "Date: %s GMT\r\n", buf2);
}

static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
{
    rtsp_reply_header(c, error_number);
    url_fprintf(c->pb, "\r\n");
}

static int rtsp_parse_request(HTTPContext *c)
{
    const char *p, *p1, *p2;
    char cmd[32];
    char url[1024];
    char protocol[32];
    char line[1024];
    ByteIOContext pb1;
    int len;
    RTSPHeader header1, *header = &header1;
    
    c->buffer_ptr[0] = '\0';
    p = c->buffer;
    
    get_word(cmd, sizeof(cmd), &p);
    get_word(url, sizeof(url), &p);
    get_word(protocol, sizeof(protocol), &p);

    pstrcpy(c->method, sizeof(c->method), cmd);
    pstrcpy(c->url, sizeof(c->url), url);
    pstrcpy(c->protocol, sizeof(c->protocol), protocol);

    c->pb = &pb1;
    if (url_open_dyn_buf(c->pb) < 0) {
        /* XXX: cannot do more */
        c->pb = NULL; /* safety */
        return -1;
    }

    /* check version name */
    if (strcmp(protocol, "RTSP/1.0") != 0) {
        rtsp_reply_error(c, RTSP_STATUS_VERSION);
        goto the_end;
    }

    /* parse each header line */
    memset(header, 0, sizeof(RTSPHeader));
    /* skip to next line */
    while (*p != '\n' && *p != '\0')
        p++;
    if (*p == '\n')
        p++;
    while (*p != '\0') {
        p1 = strchr(p, '\n');
        if (!p1)
            break;
        p2 = p1;
        if (p2 > p && p2[-1] == '\r')
            p2--;
        /* skip empty line */
        if (p2 == p)
            break;
        len = p2 - p;
        if (len > sizeof(line) - 1)
            len = sizeof(line) - 1;
        memcpy(line, p, len);
        line[len] = '\0';
        rtsp_parse_line(header, line);
        p = p1 + 1;
    }

    /* handle sequence number */
    c->seq = header->seq;

    if (!strcmp(cmd, "DESCRIBE")) {
        rtsp_cmd_describe(c, url);
    } else if (!strcmp(cmd, "SETUP")) {
        rtsp_cmd_setup(c, url, header);
    } else if (!strcmp(cmd, "PLAY")) {
        rtsp_cmd_play(c, url, header);
    } else if (!strcmp(cmd, "PAUSE")) {
        rtsp_cmd_pause(c, url, header);
    } else if (!strcmp(cmd, "TEARDOWN")) {
        rtsp_cmd_teardown(c, url, header);
    } else {
        rtsp_reply_error(c, RTSP_STATUS_METHOD);
    }
 the_end:
    len = url_close_dyn_buf(c->pb, &c->pb_buffer);
    c->pb = NULL; /* safety */
    if (len < 0) {
        /* XXX: cannot do more */
        return -1;
    }
    c->buffer_ptr = c->pb_buffer;
    c->buffer_end = c->pb_buffer + len;
    c->state = RTSPSTATE_SEND_REPLY;
    return 0;
}

static int prepare_sdp_description(HTTPContext *c, 
                                   FFStream *stream, UINT8 **pbuffer)
{
    ByteIOContext pb1, *pb = &pb1;
    struct sockaddr_in my_addr;
    int len, i, payload_type;
    const char *ipstr, *title, *mediatype;
    AVStream *st;
    
    len = sizeof(my_addr);
    getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
    ipstr = inet_ntoa(my_addr.sin_addr);

    if (url_open_dyn_buf(pb) < 0)
        return -1;
    
    /* general media info */

    url_fprintf(pb, "v=0\n");
    url_fprintf(pb, "o=- 0 0 IN IP4 %s\n", ipstr);
    title = stream->title;
    if (title[0] == '\0')
        title = "No Title";
    url_fprintf(pb, "s=%s\n", title);
    if (stream->comment[0] != '\0')
        url_fprintf(pb, "i=%s\n", stream->comment);
    
    /* for each stream, we output the necessary info */
    for(i = 0; i < stream->nb_streams; i++) {
        st = stream->streams[i];
        switch(st->codec.codec_type) {
        case CODEC_TYPE_AUDIO:
            mediatype = "audio";
            break;
        case CODEC_TYPE_VIDEO:
            mediatype = "video";
            break;
        default:
            mediatype = "application";
            break;
        }
        /* XXX: the port indication is not correct (but should be correct
           for broadcast) */
        payload_type = rtp_get_payload_type(&st->codec);

        url_fprintf(pb, "m=%s %d RTP/AVP %d\n", 
                    mediatype, 0, payload_type);
        url_fprintf(pb, "a=control:streamid=%d\n", i);
    }
    return url_close_dyn_buf(pb, pbuffer);
}

static void rtsp_cmd_describe(HTTPContext *c, const char *url)
{
    FFStream *stream;
    char path1[1024];
    const char *path;
    UINT8 *content;
    int content_length;
    
    /* find which url is asked */
    url_split(NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
    path = path1;
    if (*path == '/')
        path++;

    for(stream = first_stream; stream != NULL; stream = stream->next) {
        if (!stream->is_feed && stream->fmt == &rtp_mux &&
            !strcmp(path, stream->filename)) {
            goto found;
        }
    }
    /* no stream found */
    rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
    return;

 found:
    /* prepare the media description in sdp format */
    content_length = prepare_sdp_description(c, stream, &content);
    if (content_length < 0) {
        rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
        return;
    }
    rtsp_reply_header(c, RTSP_STATUS_OK);
    url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
    url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
    url_fprintf(c->pb, "\r\n");
    put_buffer(c->pb, content, content_length);
}

static HTTPContext *find_rtp_session(const char *session_id)
{
    HTTPContext *c;

    if (session_id[0] == '\0')
        return NULL;

    for(c = first_http_ctx; c != NULL; c = c->next) {
        if (!strcmp(c->session_id, session_id))
            return c;
    }
    return NULL;
}

RTSPTransportField *find_transport(RTSPHeader *h, enum RTSPProtocol protocol)
{
    RTSPTransportField *th;
    int i;

    for(i=0;i<h->nb_transports;i++) {
        th = &h->transports[i];
        if (th->protocol == protocol)
            return th;
    }
    return NULL;
}

static void rtsp_cmd_setup(HTTPContext *c, const char *url, 
                           RTSPHeader *h)
{
    FFStream *stream;
    int stream_index, port;
    char buf[1024];
    char path1[1024];
    const char *path;
    HTTPContext *rtp_c;
    RTSPTransportField *th;
    struct sockaddr_in dest_addr;
    RTSPActionServerSetup setup;
    
    /* find which url is asked */
    url_split(NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
    path = path1;
    if (*path == '/')
        path++;

    /* now check each stream */
    for(stream = first_stream; stream != NULL; stream = stream->next) {
        if (!stream->is_feed && stream->fmt == &rtp_mux) {
            /* accept aggregate filenames only if single stream */
            if (!strcmp(path, stream->filename)) {
                if (stream->nb_streams != 1) {
                    rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
                    return;
                }
                stream_index = 0;
                goto found;
            }
                
            for(stream_index = 0; stream_index < stream->nb_streams;
                stream_index++) {
                snprintf(buf, sizeof(buf), "%s/streamid=%d", 
                         stream->filename, stream_index);
                if (!strcmp(path, buf))
                    goto found;
            }
        }
    }
    /* no stream found */
    rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
    return;
 found:

    /* generate session id if needed */
    if (h->session_id[0] == '\0') {
        snprintf(h->session_id, sizeof(h->session_id), 
                 "%08x%08x", (int)random(), (int)random());
    }

    /* find rtp session, and create it if none found */
    rtp_c = find_rtp_session(h->session_id);
    if (!rtp_c) {
        rtp_c = rtp_new_connection(c, stream, h->session_id);
        if (!rtp_c) {
            rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
            return;
        }

        /* open input stream */
        if (open_input_stream(rtp_c, "") < 0) {
            rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
            return;
        }

        /* always prefer UDP */
        th = find_transport(h, RTSP_PROTOCOL_RTP_UDP);
        if (!th) {
            th = find_transport(h, RTSP_PROTOCOL_RTP_TCP);
            if (!th) {
                rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
                return;
            }
        }
        rtp_c->rtp_protocol = th->protocol;
    }
    
    /* test if stream is OK (test needed because several SETUP needs
       to be done for a given file) */
    if (rtp_c->stream != stream) {
        rtsp_reply_error(c, RTSP_STATUS_SERVICE);
        return;
    }
    
    /* test if stream is already set up */
    if (rtp_c->rtp_ctx[stream_index]) {
        rtsp_reply_error(c, RTSP_STATUS_STATE);
        return;
    }

    /* check transport */
    th = find_transport(h, rtp_c->rtp_protocol);
    if (!th || (th->protocol == RTSP_PROTOCOL_RTP_UDP && 
                th->client_port_min <= 0)) {
        rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
        return;
    }

    /* setup default options */
    setup.transport_option[0] = '\0';
    dest_addr = rtp_c->from_addr;
    dest_addr.sin_port = htons(th->client_port_min);
    
    /* add transport option if needed */
    if (ff_rtsp_callback) {
        setup.ipaddr = ntohl(dest_addr.sin_addr.s_addr);
        if (ff_rtsp_callback(RTSP_ACTION_SERVER_SETUP, rtp_c->session_id, 
                             (char *)&setup, sizeof(setup),
                             stream->rtsp_option) < 0) {
            rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
            return;
        }
        dest_addr.sin_addr.s_addr = htonl(setup.ipaddr);
    }
    
    /* setup stream */
    if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr) < 0) {
        rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
        return;
    }

    /* now everything is OK, so we can send the connection parameters */
    rtsp_reply_header(c, RTSP_STATUS_OK);
    /* session ID */
    url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);

    switch(rtp_c->rtp_protocol) {
    case RTSP_PROTOCOL_RTP_UDP:
        port = rtp_get_local_port(rtp_c->rtp_handles[stream_index]);
        url_fprintf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
                    "client_port=%d-%d;server_port=%d-%d",
                    th->client_port_min, th->client_port_min + 1,
                    port, port + 1);
        break;
    case RTSP_PROTOCOL_RTP_TCP:
        url_fprintf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
                    stream_index * 2, stream_index * 2 + 1);
        break;
    default:
        break;
    }
    if (setup.transport_option[0] != '\0') {
        url_fprintf(c->pb, ";%s", setup.transport_option);
    }
    url_fprintf(c->pb, "\r\n");
    

    url_fprintf(c->pb, "\r\n");
}


/* find an rtp connection by using the session ID. Check consistency
   with filename */
static HTTPContext *find_rtp_session_with_url(const char *url, 
                                              const char *session_id)
{
    HTTPContext *rtp_c;
    char path1[1024];
    const char *path;

    rtp_c = find_rtp_session(session_id);
    if (!rtp_c)
        return NULL;

    /* find which url is asked */
    url_split(NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
    path = path1;
    if (*path == '/')
        path++;
    if (strcmp(path, rtp_c->stream->filename) != 0)
        return NULL;
    return rtp_c;
}

static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h)
{
    HTTPContext *rtp_c;

    rtp_c = find_rtp_session_with_url(url, h->session_id);
    if (!rtp_c) {
        rtsp_reply_error(c, RTSP_STATUS_SESSION);
        return;
    }
    
    if (rtp_c->state != HTTPSTATE_SEND_DATA &&
        rtp_c->state != HTTPSTATE_WAIT_FEED &&
        rtp_c->state != HTTPSTATE_READY) {
        rtsp_reply_error(c, RTSP_STATUS_STATE);
        return;
    }

    rtp_c->state = HTTPSTATE_SEND_DATA;
    
    /* now everything is OK, so we can send the connection parameters */
    rtsp_reply_header(c, RTSP_STATUS_OK);
    /* session ID */
    url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
    url_fprintf(c->pb, "\r\n");
}

static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h)
{
    HTTPContext *rtp_c;

    rtp_c = find_rtp_session_with_url(url, h->session_id);
    if (!rtp_c) {
        rtsp_reply_error(c, RTSP_STATUS_SESSION);
        return;
    }
    
    if (rtp_c->state != HTTPSTATE_SEND_DATA &&
        rtp_c->state != HTTPSTATE_WAIT_FEED) {
        rtsp_reply_error(c, RTSP_STATUS_STATE);
        return;
    }
    
    rtp_c->state = HTTPSTATE_READY;
    
    /* now everything is OK, so we can send the connection parameters */
    rtsp_reply_header(c, RTSP_STATUS_OK);
    /* session ID */
    url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
    url_fprintf(c->pb, "\r\n");
}

static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h)
{
    HTTPContext *rtp_c;

    rtp_c = find_rtp_session_with_url(url, h->session_id);
    if (!rtp_c) {
        rtsp_reply_error(c, RTSP_STATUS_SESSION);
        return;
    }
    
    /* abort the session */
    close_connection(rtp_c);

    if (ff_rtsp_callback) {
        ff_rtsp_callback(RTSP_ACTION_SERVER_TEARDOWN, rtp_c->session_id, 
                         NULL, 0,
                         rtp_c->stream->rtsp_option);
    }

    /* now everything is OK, so we can send the connection parameters */
    rtsp_reply_header(c, RTSP_STATUS_OK);
    /* session ID */
    url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
    url_fprintf(c->pb, "\r\n");
}


/********************************************************************/
/* RTP handling */

static HTTPContext *rtp_new_connection(HTTPContext *rtsp_c, 
                                       FFStream *stream, const char *session_id)
{
    HTTPContext *c = NULL;

    /* XXX: should output a warning page when coming
       close to the connection limit */
    if (nb_connections >= nb_max_connections)
        goto fail;
    
    /* add a new connection */
    c = av_mallocz(sizeof(HTTPContext));
    if (!c)
        goto fail;
    
    c->fd = -1;
    c->poll_entry = NULL;
    c->from_addr = rtsp_c->from_addr;
    c->buffer_size = IOBUFFER_INIT_SIZE;
    c->buffer = av_malloc(c->buffer_size);
    if (!c->buffer)
        goto fail;
    nb_connections++;
    c->stream = stream;
    pstrcpy(c->session_id, sizeof(c->session_id), session_id);
    c->state = HTTPSTATE_READY;
    c->is_packetized = 1;
    /* protocol is shown in statistics */
    pstrcpy(c->protocol, sizeof(c->protocol), "RTP");

    c->next = first_http_ctx;
    first_http_ctx = c;
    return c;
        
 fail:
    if (c) {
        av_free(c->buffer);
        av_free(c);
    }
    return NULL;
}

/* add a new RTP stream in an RTP connection (used in RTSP SETUP
   command). if dest_addr is NULL, then TCP tunneling in RTSP is
   used. */
static int rtp_new_av_stream(HTTPContext *c, 
                             int stream_index, struct sockaddr_in *dest_addr)
{
    AVFormatContext *ctx;
    AVStream *st;
    char *ipaddr;
    URLContext *h;
    UINT8 *dummy_buf;

    /* now we can open the relevant output stream */
    ctx = av_mallocz(sizeof(AVFormatContext));
    if (!ctx)
        return -1;
    ctx->oformat = &rtp_mux;

    st = av_mallocz(sizeof(AVStream));
    if (!st)
        goto fail;
    ctx->nb_streams = 1;
    ctx->streams[0] = st;

    if (!c->stream->feed || 
        c->stream->feed == c->stream) {
        memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
    } else {
        memcpy(st, 
               c->stream->feed->streams[c->stream->feed_streams[stream_index]],
               sizeof(AVStream));
    }
    
    if (dest_addr) {
        /* build destination RTP address */
        ipaddr = inet_ntoa(dest_addr->sin_addr);
        
        snprintf(ctx->filename, sizeof(ctx->filename),
                 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
        
        printf("open %s\n", ctx->filename);

        if (url_open(&h, ctx->filename, URL_WRONLY) < 0)
            goto fail;
        c->rtp_handles[stream_index] = h;
    } else {
        goto fail;
    }

    /* normally, no packets should be output here, but the packet size may be checked */
    if (url_open_dyn_packet_buf(&ctx->pb, 
                                url_get_max_packet_size(h)) < 0) {
        /* XXX: close stream */
        goto fail;
    }
    if (av_write_header(ctx) < 0) {
    fail:
        if (h)
            url_close(h);
        av_free(ctx);
        return -1;
    }
    url_close_dyn_buf(&ctx->pb, &dummy_buf);
    av_free(dummy_buf);
    
    c->rtp_ctx[stream_index] = ctx;
    return 0;
}

/********************************************************************/
/* ffserver initialization */

AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
{
    AVStream *fst;

    fst = av_mallocz(sizeof(AVStream));
    if (!fst)
        return NULL;
    fst->priv_data = av_mallocz(sizeof(FeedData));
    memcpy(&fst->codec, codec, sizeof(AVCodecContext));
    stream->streams[stream->nb_streams++] = fst;
    return fst;
}

/* return the stream number in the feed */
int add_av_stream(FFStream *feed,
                  AVStream *st)
{
    AVStream *fst;
    AVCodecContext *av, *av1;
    int i;

    av = &st->codec;
    for(i=0;i<feed->nb_streams;i++) {
        st = feed->streams[i];
        av1 = &st->codec;
        if (av1->codec_id == av->codec_id &&
            av1->codec_type == av->codec_type &&
            av1->bit_rate == av->bit_rate) {

            switch(av->codec_type) {
            case CODEC_TYPE_AUDIO:
                if (av1->channels == av->channels &&
                    av1->sample_rate == av->sample_rate)
                    goto found;
                break;
            case CODEC_TYPE_VIDEO:
                if (av1->width == av->width &&
                    av1->height == av->height &&
                    av1->frame_rate == av->frame_rate &&
                    av1->gop_size == av->gop_size)
                    goto found;
                break;
            default:
                av_abort();
            }
        }
    }
    
    fst = add_av_stream1(feed, av);
    if (!fst)
        return -1;
    return feed->nb_streams - 1;
 found:
    return i;
}

void remove_stream(FFStream *stream)
{
    FFStream **ps;
    ps = &first_stream;
    while (*ps != NULL) {
        if (*ps == stream) {
            *ps = (*ps)->next;
        } else {
            ps = &(*ps)->next;
        }
    }
}