Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * RTSP/SDP client
  3.  * Copyright (c) 2002 Fabrice Bellard
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include "libavutil/avassert.h"
  23. #include "libavutil/base64.h"
  24. #include "libavutil/avstring.h"
  25. #include "libavutil/intreadwrite.h"
  26. #include "libavutil/mathematics.h"
  27. #include "libavutil/parseutils.h"
  28. #include "libavutil/random_seed.h"
  29. #include "libavutil/dict.h"
  30. #include "libavutil/opt.h"
  31. #include "libavutil/time.h"
  32. #include "avformat.h"
  33. #include "avio_internal.h"
  34.  
  35. #if HAVE_POLL_H
  36. #include <poll.h>
  37. #endif
  38. #include "internal.h"
  39. #include "network.h"
  40. #include "os_support.h"
  41. #include "http.h"
  42. #include "rtsp.h"
  43.  
  44. #include "rtpdec.h"
  45. #include "rtpproto.h"
  46. #include "rdt.h"
  47. #include "rtpdec_formats.h"
  48. #include "rtpenc_chain.h"
  49. #include "url.h"
  50. #include "rtpenc.h"
  51. #include "mpegts.h"
  52.  
  53. /* Timeout values for socket poll, in ms,
  54.  * and read_packet(), in seconds  */
  55. #define POLL_TIMEOUT_MS 100
  56. #define READ_PACKET_TIMEOUT_S 10
  57. #define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS
  58. #define SDP_MAX_SIZE 16384
  59. #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
  60. #define DEFAULT_REORDERING_DELAY 100000
  61.  
  62. #define OFFSET(x) offsetof(RTSPState, x)
  63. #define DEC AV_OPT_FLAG_DECODING_PARAM
  64. #define ENC AV_OPT_FLAG_ENCODING_PARAM
  65.  
  66. #define RTSP_FLAG_OPTS(name, longname) \
  67.     { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \
  68.     { "filter_src", "Only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, "rtsp_flags" }
  69.  
  70. #define RTSP_MEDIATYPE_OPTS(name, longname) \
  71.     { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_DATA+1)) - 1 }, INT_MIN, INT_MAX, DEC, "allowed_media_types" }, \
  72.     { "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \
  73.     { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \
  74.     { "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" }
  75.  
  76. #define RTSP_REORDERING_OPTS() \
  77.     { "reorder_queue_size", "Number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }
  78.  
  79. const AVOption ff_rtsp_options[] = {
  80.     { "initial_pause",  "Don't start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC },
  81.     FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
  82.     { "rtsp_transport", "RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, "rtsp_transport" }, \
  83.     { "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
  84.     { "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
  85.     { "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, "rtsp_transport" },
  86.     { "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, "rtsp_transport" },
  87.     RTSP_FLAG_OPTS("rtsp_flags", "RTSP flags"),
  88.     { "listen", "Wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, "rtsp_flags" },
  89.     RTSP_MEDIATYPE_OPTS("allowed_media_types", "Media types to accept from the server"),
  90.     { "min_port", "Minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },
  91.     { "max_port", "Maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },
  92.     { "timeout", "Maximum timeout (in seconds) to wait for incoming connections. -1 is infinite. Implies flag listen", OFFSET(initial_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC },
  93.     { "stimeout", "timeout (in micro seconds) of socket i/o operations.", OFFSET(stimeout), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC },
  94.     RTSP_REORDERING_OPTS(),
  95.     { "user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },
  96.     { NULL },
  97. };
  98.  
  99. static const AVOption sdp_options[] = {
  100.     RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
  101.     { "custom_io", "Use custom IO", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, "rtsp_flags" },
  102.     { "rtcp_to_source", "Send RTCP packets to the source address of received packets", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_RTCP_TO_SOURCE}, 0, 0, DEC, "rtsp_flags" },
  103.     RTSP_MEDIATYPE_OPTS("allowed_media_types", "Media types to accept from the server"),
  104.     RTSP_REORDERING_OPTS(),
  105.     { NULL },
  106. };
  107.  
  108. static const AVOption rtp_options[] = {
  109.     RTSP_FLAG_OPTS("rtp_flags", "RTP flags"),
  110.     RTSP_REORDERING_OPTS(),
  111.     { NULL },
  112. };
  113.  
  114. static void get_word_until_chars(char *buf, int buf_size,
  115.                                  const char *sep, const char **pp)
  116. {
  117.     const char *p;
  118.     char *q;
  119.  
  120.     p = *pp;
  121.     p += strspn(p, SPACE_CHARS);
  122.     q = buf;
  123.     while (!strchr(sep, *p) && *p != '\0') {
  124.         if ((q - buf) < buf_size - 1)
  125.             *q++ = *p;
  126.         p++;
  127.     }
  128.     if (buf_size > 0)
  129.         *q = '\0';
  130.     *pp = p;
  131. }
  132.  
  133. static void get_word_sep(char *buf, int buf_size, const char *sep,
  134.                          const char **pp)
  135. {
  136.     if (**pp == '/') (*pp)++;
  137.     get_word_until_chars(buf, buf_size, sep, pp);
  138. }
  139.  
  140. static void get_word(char *buf, int buf_size, const char **pp)
  141. {
  142.     get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
  143. }
  144.  
  145. /** Parse a string p in the form of Range:npt=xx-xx, and determine the start
  146.  *  and end time.
  147.  *  Used for seeking in the rtp stream.
  148.  */
  149. static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
  150. {
  151.     char buf[256];
  152.  
  153.     p += strspn(p, SPACE_CHARS);
  154.     if (!av_stristart(p, "npt=", &p))
  155.         return;
  156.  
  157.     *start = AV_NOPTS_VALUE;
  158.     *end = AV_NOPTS_VALUE;
  159.  
  160.     get_word_sep(buf, sizeof(buf), "-", &p);
  161.     av_parse_time(start, buf, 1);
  162.     if (*p == '-') {
  163.         p++;
  164.         get_word_sep(buf, sizeof(buf), "-", &p);
  165.         av_parse_time(end, buf, 1);
  166.     }
  167. }
  168.  
  169. static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
  170. {
  171.     struct addrinfo hints = { 0 }, *ai = NULL;
  172.     hints.ai_flags = AI_NUMERICHOST;
  173.     if (getaddrinfo(buf, NULL, &hints, &ai))
  174.         return -1;
  175.     memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
  176.     freeaddrinfo(ai);
  177.     return 0;
  178. }
  179.  
  180. #if CONFIG_RTPDEC
  181. static void init_rtp_handler(RTPDynamicProtocolHandler *handler,
  182.                              RTSPStream *rtsp_st, AVCodecContext *codec)
  183. {
  184.     if (!handler)
  185.         return;
  186.     if (codec)
  187.         codec->codec_id          = handler->codec_id;
  188.     rtsp_st->dynamic_handler = handler;
  189.     if (handler->alloc) {
  190.         rtsp_st->dynamic_protocol_context = handler->alloc();
  191.         if (!rtsp_st->dynamic_protocol_context)
  192.             rtsp_st->dynamic_handler = NULL;
  193.     }
  194. }
  195.  
  196. /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
  197. static int sdp_parse_rtpmap(AVFormatContext *s,
  198.                             AVStream *st, RTSPStream *rtsp_st,
  199.                             int payload_type, const char *p)
  200. {
  201.     AVCodecContext *codec = st->codec;
  202.     char buf[256];
  203.     int i;
  204.     AVCodec *c;
  205.     const char *c_name;
  206.  
  207.     /* See if we can handle this kind of payload.
  208.      * The space should normally not be there but some Real streams or
  209.      * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
  210.      * have a trailing space. */
  211.     get_word_sep(buf, sizeof(buf), "/ ", &p);
  212.     if (payload_type < RTP_PT_PRIVATE) {
  213.         /* We are in a standard case
  214.          * (from http://www.iana.org/assignments/rtp-parameters). */
  215.         codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
  216.     }
  217.  
  218.     if (codec->codec_id == AV_CODEC_ID_NONE) {
  219.         RTPDynamicProtocolHandler *handler =
  220.             ff_rtp_handler_find_by_name(buf, codec->codec_type);
  221.         init_rtp_handler(handler, rtsp_st, codec);
  222.         /* If no dynamic handler was found, check with the list of standard
  223.          * allocated types, if such a stream for some reason happens to
  224.          * use a private payload type. This isn't handled in rtpdec.c, since
  225.          * the format name from the rtpmap line never is passed into rtpdec. */
  226.         if (!rtsp_st->dynamic_handler)
  227.             codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
  228.     }
  229.  
  230.     c = avcodec_find_decoder(codec->codec_id);
  231.     if (c && c->name)
  232.         c_name = c->name;
  233.     else
  234.         c_name = "(null)";
  235.  
  236.     get_word_sep(buf, sizeof(buf), "/", &p);
  237.     i = atoi(buf);
  238.     switch (codec->codec_type) {
  239.     case AVMEDIA_TYPE_AUDIO:
  240.         av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
  241.         codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
  242.         codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
  243.         if (i > 0) {
  244.             codec->sample_rate = i;
  245.             avpriv_set_pts_info(st, 32, 1, codec->sample_rate);
  246.             get_word_sep(buf, sizeof(buf), "/", &p);
  247.             i = atoi(buf);
  248.             if (i > 0)
  249.                 codec->channels = i;
  250.         }
  251.         av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
  252.                codec->sample_rate);
  253.         av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
  254.                codec->channels);
  255.         break;
  256.     case AVMEDIA_TYPE_VIDEO:
  257.         av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
  258.         if (i > 0)
  259.             avpriv_set_pts_info(st, 32, 1, i);
  260.         break;
  261.     default:
  262.         break;
  263.     }
  264.     if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init)
  265.         rtsp_st->dynamic_handler->init(s, st->index,
  266.                                        rtsp_st->dynamic_protocol_context);
  267.     return 0;
  268. }
  269.  
  270. /* parse the attribute line from the fmtp a line of an sdp response. This
  271.  * is broken out as a function because it is used in rtp_h264.c, which is
  272.  * forthcoming. */
  273. int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
  274.                                 char *value, int value_size)
  275. {
  276.     *p += strspn(*p, SPACE_CHARS);
  277.     if (**p) {
  278.         get_word_sep(attr, attr_size, "=", p);
  279.         if (**p == '=')
  280.             (*p)++;
  281.         get_word_sep(value, value_size, ";", p);
  282.         if (**p == ';')
  283.             (*p)++;
  284.         return 1;
  285.     }
  286.     return 0;
  287. }
  288.  
  289. typedef struct SDPParseState {
  290.     /* SDP only */
  291.     struct sockaddr_storage default_ip;
  292.     int            default_ttl;
  293.     int            skip_media;  ///< set if an unknown m= line occurs
  294.     int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */
  295.     struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */
  296.     int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
  297.     struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */
  298. } SDPParseState;
  299.  
  300. static void copy_default_source_addrs(struct RTSPSource **addrs, int count,
  301.                                       struct RTSPSource ***dest, int *dest_count)
  302. {
  303.     RTSPSource *rtsp_src, *rtsp_src2;
  304.     int i;
  305.     for (i = 0; i < count; i++) {
  306.         rtsp_src = addrs[i];
  307.         rtsp_src2 = av_malloc(sizeof(*rtsp_src2));
  308.         if (!rtsp_src2)
  309.             continue;
  310.         memcpy(rtsp_src2, rtsp_src, sizeof(*rtsp_src));
  311.         dynarray_add(dest, dest_count, rtsp_src2);
  312.     }
  313. }
  314.  
  315. static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
  316.                            int letter, const char *buf)
  317. {
  318.     RTSPState *rt = s->priv_data;
  319.     char buf1[64], st_type[64];
  320.     const char *p;
  321.     enum AVMediaType codec_type;
  322.     int payload_type, i;
  323.     AVStream *st;
  324.     RTSPStream *rtsp_st;
  325.     RTSPSource *rtsp_src;
  326.     struct sockaddr_storage sdp_ip;
  327.     int ttl;
  328.  
  329.     av_dlog(s, "sdp: %c='%s'\n", letter, buf);
  330.  
  331.     p = buf;
  332.     if (s1->skip_media && letter != 'm')
  333.         return;
  334.     switch (letter) {
  335.     case 'c':
  336.         get_word(buf1, sizeof(buf1), &p);
  337.         if (strcmp(buf1, "IN") != 0)
  338.             return;
  339.         get_word(buf1, sizeof(buf1), &p);
  340.         if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
  341.             return;
  342.         get_word_sep(buf1, sizeof(buf1), "/", &p);
  343.         if (get_sockaddr(buf1, &sdp_ip))
  344.             return;
  345.         ttl = 16;
  346.         if (*p == '/') {
  347.             p++;
  348.             get_word_sep(buf1, sizeof(buf1), "/", &p);
  349.             ttl = atoi(buf1);
  350.         }
  351.         if (s->nb_streams == 0) {
  352.             s1->default_ip = sdp_ip;
  353.             s1->default_ttl = ttl;
  354.         } else {
  355.             rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
  356.             rtsp_st->sdp_ip = sdp_ip;
  357.             rtsp_st->sdp_ttl = ttl;
  358.         }
  359.         break;
  360.     case 's':
  361.         av_dict_set(&s->metadata, "title", p, 0);
  362.         break;
  363.     case 'i':
  364.         if (s->nb_streams == 0) {
  365.             av_dict_set(&s->metadata, "comment", p, 0);
  366.             break;
  367.         }
  368.         break;
  369.     case 'm':
  370.         /* new stream */
  371.         s1->skip_media = 0;
  372.         codec_type = AVMEDIA_TYPE_UNKNOWN;
  373.         get_word(st_type, sizeof(st_type), &p);
  374.         if (!strcmp(st_type, "audio")) {
  375.             codec_type = AVMEDIA_TYPE_AUDIO;
  376.         } else if (!strcmp(st_type, "video")) {
  377.             codec_type = AVMEDIA_TYPE_VIDEO;
  378.         } else if (!strcmp(st_type, "application")) {
  379.             codec_type = AVMEDIA_TYPE_DATA;
  380.         }
  381.         if (codec_type == AVMEDIA_TYPE_UNKNOWN || !(rt->media_type_mask & (1 << codec_type))) {
  382.             s1->skip_media = 1;
  383.             return;
  384.         }
  385.         rtsp_st = av_mallocz(sizeof(RTSPStream));
  386.         if (!rtsp_st)
  387.             return;
  388.         rtsp_st->stream_index = -1;
  389.         dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
  390.  
  391.         rtsp_st->sdp_ip = s1->default_ip;
  392.         rtsp_st->sdp_ttl = s1->default_ttl;
  393.  
  394.         copy_default_source_addrs(s1->default_include_source_addrs,
  395.                                   s1->nb_default_include_source_addrs,
  396.                                   &rtsp_st->include_source_addrs,
  397.                                   &rtsp_st->nb_include_source_addrs);
  398.         copy_default_source_addrs(s1->default_exclude_source_addrs,
  399.                                   s1->nb_default_exclude_source_addrs,
  400.                                   &rtsp_st->exclude_source_addrs,
  401.                                   &rtsp_st->nb_exclude_source_addrs);
  402.  
  403.         get_word(buf1, sizeof(buf1), &p); /* port */
  404.         rtsp_st->sdp_port = atoi(buf1);
  405.  
  406.         get_word(buf1, sizeof(buf1), &p); /* protocol */
  407.         if (!strcmp(buf1, "udp"))
  408.             rt->transport = RTSP_TRANSPORT_RAW;
  409.         else if (strstr(buf1, "/AVPF") || strstr(buf1, "/SAVPF"))
  410.             rtsp_st->feedback = 1;
  411.  
  412.         /* XXX: handle list of formats */
  413.         get_word(buf1, sizeof(buf1), &p); /* format list */
  414.         rtsp_st->sdp_payload_type = atoi(buf1);
  415.  
  416.         if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
  417.             /* no corresponding stream */
  418.             if (rt->transport == RTSP_TRANSPORT_RAW) {
  419.                 if (!rt->ts && CONFIG_RTPDEC)
  420.                     rt->ts = ff_mpegts_parse_open(s);
  421.             } else {
  422.                 RTPDynamicProtocolHandler *handler;
  423.                 handler = ff_rtp_handler_find_by_id(
  424.                               rtsp_st->sdp_payload_type, AVMEDIA_TYPE_DATA);
  425.                 init_rtp_handler(handler, rtsp_st, NULL);
  426.                 if (handler && handler->init)
  427.                     handler->init(s, -1, rtsp_st->dynamic_protocol_context);
  428.             }
  429.         } else if (rt->server_type == RTSP_SERVER_WMS &&
  430.                    codec_type == AVMEDIA_TYPE_DATA) {
  431.             /* RTX stream, a stream that carries all the other actual
  432.              * audio/video streams. Don't expose this to the callers. */
  433.         } else {
  434.             st = avformat_new_stream(s, NULL);
  435.             if (!st)
  436.                 return;
  437.             st->id = rt->nb_rtsp_streams - 1;
  438.             rtsp_st->stream_index = st->index;
  439.             st->codec->codec_type = codec_type;
  440.             if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
  441.                 RTPDynamicProtocolHandler *handler;
  442.                 /* if standard payload type, we can find the codec right now */
  443.                 ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
  444.                 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
  445.                     st->codec->sample_rate > 0)
  446.                     avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
  447.                 /* Even static payload types may need a custom depacketizer */
  448.                 handler = ff_rtp_handler_find_by_id(
  449.                               rtsp_st->sdp_payload_type, st->codec->codec_type);
  450.                 init_rtp_handler(handler, rtsp_st, st->codec);
  451.                 if (handler && handler->init)
  452.                     handler->init(s, st->index,
  453.                                   rtsp_st->dynamic_protocol_context);
  454.             }
  455.         }
  456.         /* put a default control url */
  457.         av_strlcpy(rtsp_st->control_url, rt->control_uri,
  458.                    sizeof(rtsp_st->control_url));
  459.         break;
  460.     case 'a':
  461.         if (av_strstart(p, "control:", &p)) {
  462.             if (s->nb_streams == 0) {
  463.                 if (!strncmp(p, "rtsp://", 7))
  464.                     av_strlcpy(rt->control_uri, p,
  465.                                sizeof(rt->control_uri));
  466.             } else {
  467.                 char proto[32];
  468.                 /* get the control url */
  469.                 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
  470.  
  471.                 /* XXX: may need to add full url resolution */
  472.                 av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
  473.                              NULL, NULL, 0, p);
  474.                 if (proto[0] == '\0') {
  475.                     /* relative control URL */
  476.                     if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
  477.                     av_strlcat(rtsp_st->control_url, "/",
  478.                                sizeof(rtsp_st->control_url));
  479.                     av_strlcat(rtsp_st->control_url, p,
  480.                                sizeof(rtsp_st->control_url));
  481.                 } else
  482.                     av_strlcpy(rtsp_st->control_url, p,
  483.                                sizeof(rtsp_st->control_url));
  484.             }
  485.         } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
  486.             /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
  487.             get_word(buf1, sizeof(buf1), &p);
  488.             payload_type = atoi(buf1);
  489.             rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
  490.             if (rtsp_st->stream_index >= 0) {
  491.                 st = s->streams[rtsp_st->stream_index];
  492.                 sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
  493.             }
  494.         } else if (av_strstart(p, "fmtp:", &p) ||
  495.                    av_strstart(p, "framesize:", &p)) {
  496.             /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
  497.             // let dynamic protocol handlers have a stab at the line.
  498.             get_word(buf1, sizeof(buf1), &p);
  499.             payload_type = atoi(buf1);
  500.             for (i = 0; i < rt->nb_rtsp_streams; i++) {
  501.                 rtsp_st = rt->rtsp_streams[i];
  502.                 if (rtsp_st->sdp_payload_type == payload_type &&
  503.                     rtsp_st->dynamic_handler &&
  504.                     rtsp_st->dynamic_handler->parse_sdp_a_line)
  505.                     rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
  506.                         rtsp_st->dynamic_protocol_context, buf);
  507.             }
  508.         } else if (av_strstart(p, "range:", &p)) {
  509.             int64_t start, end;
  510.  
  511.             // this is so that seeking on a streamed file can work.
  512.             rtsp_parse_range_npt(p, &start, &end);
  513.             s->start_time = start;
  514.             /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
  515.             s->duration   = (end == AV_NOPTS_VALUE) ?
  516.                             AV_NOPTS_VALUE : end - start;
  517.         } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
  518.             if (atoi(p) == 1)
  519.                 rt->transport = RTSP_TRANSPORT_RDT;
  520.         } else if (av_strstart(p, "SampleRate:integer;", &p) &&
  521.                    s->nb_streams > 0) {
  522.             st = s->streams[s->nb_streams - 1];
  523.             st->codec->sample_rate = atoi(p);
  524.         } else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {
  525.             // RFC 4568
  526.             rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
  527.             get_word(buf1, sizeof(buf1), &p); // ignore tag
  528.             get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);
  529.             p += strspn(p, SPACE_CHARS);
  530.             if (av_strstart(p, "inline:", &p))
  531.                 get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);
  532.         } else if (av_strstart(p, "source-filter:", &p)) {
  533.             int exclude = 0;
  534.             get_word(buf1, sizeof(buf1), &p);
  535.             if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))
  536.                 return;
  537.             exclude = !strcmp(buf1, "excl");
  538.  
  539.             get_word(buf1, sizeof(buf1), &p);
  540.             if (strcmp(buf1, "IN") != 0)
  541.                 return;
  542.             get_word(buf1, sizeof(buf1), &p);
  543.             if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))
  544.                 return;
  545.             // not checking that the destination address actually matches or is wildcard
  546.             get_word(buf1, sizeof(buf1), &p);
  547.  
  548.             while (*p != '\0') {
  549.                 rtsp_src = av_mallocz(sizeof(*rtsp_src));
  550.                 if (!rtsp_src)
  551.                     return;
  552.                 get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);
  553.                 if (exclude) {
  554.                     if (s->nb_streams == 0) {
  555.                         dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
  556.                     } else {
  557.                         rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
  558.                         dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);
  559.                     }
  560.                 } else {
  561.                     if (s->nb_streams == 0) {
  562.                         dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
  563.                     } else {
  564.                         rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
  565.                         dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);
  566.                     }
  567.                 }
  568.             }
  569.         } else {
  570.             if (rt->server_type == RTSP_SERVER_WMS)
  571.                 ff_wms_parse_sdp_a_line(s, p);
  572.             if (s->nb_streams > 0) {
  573.                 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
  574.  
  575.                 if (rt->server_type == RTSP_SERVER_REAL)
  576.                     ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p);
  577.  
  578.                 if (rtsp_st->dynamic_handler &&
  579.                     rtsp_st->dynamic_handler->parse_sdp_a_line)
  580.                     rtsp_st->dynamic_handler->parse_sdp_a_line(s,
  581.                         rtsp_st->stream_index,
  582.                         rtsp_st->dynamic_protocol_context, buf);
  583.             }
  584.         }
  585.         break;
  586.     }
  587. }
  588.  
  589. int ff_sdp_parse(AVFormatContext *s, const char *content)
  590. {
  591.     RTSPState *rt = s->priv_data;
  592.     const char *p;
  593.     int letter, i;
  594.     /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
  595.      * contain long SDP lines containing complete ASF Headers (several
  596.      * kB) or arrays of MDPR (RM stream descriptor) headers plus
  597.      * "rulebooks" describing their properties. Therefore, the SDP line
  598.      * buffer is large.
  599.      *
  600.      * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
  601.      * in rtpdec_xiph.c. */
  602.     char buf[16384], *q;
  603.     SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
  604.  
  605.     p = content;
  606.     for (;;) {
  607.         p += strspn(p, SPACE_CHARS);
  608.         letter = *p;
  609.         if (letter == '\0')
  610.             break;
  611.         p++;
  612.         if (*p != '=')
  613.             goto next_line;
  614.         p++;
  615.         /* get the content */
  616.         q = buf;
  617.         while (*p != '\n' && *p != '\r' && *p != '\0') {
  618.             if ((q - buf) < sizeof(buf) - 1)
  619.                 *q++ = *p;
  620.             p++;
  621.         }
  622.         *q = '\0';
  623.         sdp_parse_line(s, s1, letter, buf);
  624.     next_line:
  625.         while (*p != '\n' && *p != '\0')
  626.             p++;
  627.         if (*p == '\n')
  628.             p++;
  629.     }
  630.  
  631.     for (i = 0; i < s1->nb_default_include_source_addrs; i++)
  632.         av_free(s1->default_include_source_addrs[i]);
  633.     av_freep(&s1->default_include_source_addrs);
  634.     for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
  635.         av_free(s1->default_exclude_source_addrs[i]);
  636.     av_freep(&s1->default_exclude_source_addrs);
  637.  
  638.     rt->p = av_malloc(sizeof(struct pollfd)*2*(rt->nb_rtsp_streams+1));
  639.     if (!rt->p) return AVERROR(ENOMEM);
  640.     return 0;
  641. }
  642. #endif /* CONFIG_RTPDEC */
  643.  
  644. void ff_rtsp_undo_setup(AVFormatContext *s)
  645. {
  646.     RTSPState *rt = s->priv_data;
  647.     int i;
  648.  
  649.     for (i = 0; i < rt->nb_rtsp_streams; i++) {
  650.         RTSPStream *rtsp_st = rt->rtsp_streams[i];
  651.         if (!rtsp_st)
  652.             continue;
  653.         if (rtsp_st->transport_priv) {
  654.             if (s->oformat) {
  655.                 AVFormatContext *rtpctx = rtsp_st->transport_priv;
  656.                 av_write_trailer(rtpctx);
  657.                 if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
  658.                     uint8_t *ptr;
  659.                     avio_close_dyn_buf(rtpctx->pb, &ptr);
  660.                     av_free(ptr);
  661.                 } else {
  662.                     avio_close(rtpctx->pb);
  663.                 }
  664.                 avformat_free_context(rtpctx);
  665.             } else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC)
  666.                 ff_rdt_parse_close(rtsp_st->transport_priv);
  667.             else if (rt->transport == RTSP_TRANSPORT_RTP && CONFIG_RTPDEC)
  668.                 ff_rtp_parse_close(rtsp_st->transport_priv);
  669.         }
  670.         rtsp_st->transport_priv = NULL;
  671.         if (rtsp_st->rtp_handle)
  672.             ffurl_close(rtsp_st->rtp_handle);
  673.         rtsp_st->rtp_handle = NULL;
  674.     }
  675. }
  676.  
  677. /* close and free RTSP streams */
  678. void ff_rtsp_close_streams(AVFormatContext *s)
  679. {
  680.     RTSPState *rt = s->priv_data;
  681.     int i, j;
  682.     RTSPStream *rtsp_st;
  683.  
  684.     ff_rtsp_undo_setup(s);
  685.     for (i = 0; i < rt->nb_rtsp_streams; i++) {
  686.         rtsp_st = rt->rtsp_streams[i];
  687.         if (rtsp_st) {
  688.             if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
  689.                 rtsp_st->dynamic_handler->free(
  690.                     rtsp_st->dynamic_protocol_context);
  691.             for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)
  692.                 av_free(rtsp_st->include_source_addrs[j]);
  693.             av_freep(&rtsp_st->include_source_addrs);
  694.             for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)
  695.                 av_free(rtsp_st->exclude_source_addrs[j]);
  696.             av_freep(&rtsp_st->exclude_source_addrs);
  697.  
  698.             av_free(rtsp_st);
  699.         }
  700.     }
  701.     av_free(rt->rtsp_streams);
  702.     if (rt->asf_ctx) {
  703.         avformat_close_input(&rt->asf_ctx);
  704.     }
  705.     if (rt->ts && CONFIG_RTPDEC)
  706.         ff_mpegts_parse_close(rt->ts);
  707.     av_free(rt->p);
  708.     av_free(rt->recvbuf);
  709. }
  710.  
  711. int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
  712. {
  713.     RTSPState *rt = s->priv_data;
  714.     AVStream *st = NULL;
  715.     int reordering_queue_size = rt->reordering_queue_size;
  716.     if (reordering_queue_size < 0) {
  717.         if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
  718.             reordering_queue_size = 0;
  719.         else
  720.             reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
  721.     }
  722.  
  723.     /* open the RTP context */
  724.     if (rtsp_st->stream_index >= 0)
  725.         st = s->streams[rtsp_st->stream_index];
  726.     if (!st)
  727.         s->ctx_flags |= AVFMTCTX_NOHEADER;
  728.  
  729.     if (s->oformat && CONFIG_RTSP_MUXER) {
  730.         int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv, s, st,
  731.                                         rtsp_st->rtp_handle,
  732.                                         RTSP_TCP_MAX_PACKET_SIZE,
  733.                                         rtsp_st->stream_index);
  734.         /* Ownership of rtp_handle is passed to the rtp mux context */
  735.         rtsp_st->rtp_handle = NULL;
  736.         if (ret < 0)
  737.             return ret;
  738.     } else if (rt->transport == RTSP_TRANSPORT_RAW) {
  739.         return 0; // Don't need to open any parser here
  740.     } else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC)
  741.         rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
  742.                                             rtsp_st->dynamic_protocol_context,
  743.                                             rtsp_st->dynamic_handler);
  744.     else if (CONFIG_RTPDEC)
  745.         rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
  746.                                          rtsp_st->sdp_payload_type,
  747.                                          reordering_queue_size);
  748.  
  749.     if (!rtsp_st->transport_priv) {
  750.          return AVERROR(ENOMEM);
  751.     } else if (rt->transport == RTSP_TRANSPORT_RTP && CONFIG_RTPDEC) {
  752.         if (rtsp_st->dynamic_handler) {
  753.             ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
  754.                                               rtsp_st->dynamic_protocol_context,
  755.                                               rtsp_st->dynamic_handler);
  756.         }
  757.         if (rtsp_st->crypto_suite[0])
  758.             ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
  759.                                     rtsp_st->crypto_suite,
  760.                                     rtsp_st->crypto_params);
  761.     }
  762.  
  763.     return 0;
  764. }
  765.  
  766. #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
  767. static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
  768. {
  769.     const char *q;
  770.     char *p;
  771.     int v;
  772.  
  773.     q = *pp;
  774.     q += strspn(q, SPACE_CHARS);
  775.     v = strtol(q, &p, 10);
  776.     if (*p == '-') {
  777.         p++;
  778.         *min_ptr = v;
  779.         v = strtol(p, &p, 10);
  780.         *max_ptr = v;
  781.     } else {
  782.         *min_ptr = v;
  783.         *max_ptr = v;
  784.     }
  785.     *pp = p;
  786. }
  787.  
  788. /* XXX: only one transport specification is parsed */
  789. static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
  790. {
  791.     char transport_protocol[16];
  792.     char profile[16];
  793.     char lower_transport[16];
  794.     char parameter[16];
  795.     RTSPTransportField *th;
  796.     char buf[256];
  797.  
  798.     reply->nb_transports = 0;
  799.  
  800.     for (;;) {
  801.         p += strspn(p, SPACE_CHARS);
  802.         if (*p == '\0')
  803.             break;
  804.  
  805.         th = &reply->transports[reply->nb_transports];
  806.  
  807.         get_word_sep(transport_protocol, sizeof(transport_protocol),
  808.                      "/", &p);
  809.         if (!av_strcasecmp (transport_protocol, "rtp")) {
  810.             get_word_sep(profile, sizeof(profile), "/;,", &p);
  811.             lower_transport[0] = '\0';
  812.             /* rtp/avp/<protocol> */
  813.             if (*p == '/') {
  814.                 get_word_sep(lower_transport, sizeof(lower_transport),
  815.                              ";,", &p);
  816.             }
  817.             th->transport = RTSP_TRANSPORT_RTP;
  818.         } else if (!av_strcasecmp (transport_protocol, "x-pn-tng") ||
  819.                    !av_strcasecmp (transport_protocol, "x-real-rdt")) {
  820.             /* x-pn-tng/<protocol> */
  821.             get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
  822.             profile[0] = '\0';
  823.             th->transport = RTSP_TRANSPORT_RDT;
  824.         } else if (!av_strcasecmp(transport_protocol, "raw")) {
  825.             get_word_sep(profile, sizeof(profile), "/;,", &p);
  826.             lower_transport[0] = '\0';
  827.             /* raw/raw/<protocol> */
  828.             if (*p == '/') {
  829.                 get_word_sep(lower_transport, sizeof(lower_transport),
  830.                              ";,", &p);
  831.             }
  832.             th->transport = RTSP_TRANSPORT_RAW;
  833.         }
  834.         if (!av_strcasecmp(lower_transport, "TCP"))
  835.             th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
  836.         else
  837.             th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
  838.  
  839.         if (*p == ';')
  840.             p++;
  841.         /* get each parameter */
  842.         while (*p != '\0' && *p != ',') {
  843.             get_word_sep(parameter, sizeof(parameter), "=;,", &p);
  844.             if (!strcmp(parameter, "port")) {
  845.                 if (*p == '=') {
  846.                     p++;
  847.                     rtsp_parse_range(&th->port_min, &th->port_max, &p);
  848.                 }
  849.             } else if (!strcmp(parameter, "client_port")) {
  850.                 if (*p == '=') {
  851.                     p++;
  852.                     rtsp_parse_range(&th->client_port_min,
  853.                                      &th->client_port_max, &p);
  854.                 }
  855.             } else if (!strcmp(parameter, "server_port")) {
  856.                 if (*p == '=') {
  857.                     p++;
  858.                     rtsp_parse_range(&th->server_port_min,
  859.                                      &th->server_port_max, &p);
  860.                 }
  861.             } else if (!strcmp(parameter, "interleaved")) {
  862.                 if (*p == '=') {
  863.                     p++;
  864.                     rtsp_parse_range(&th->interleaved_min,
  865.                                      &th->interleaved_max, &p);
  866.                 }
  867.             } else if (!strcmp(parameter, "multicast")) {
  868.                 if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
  869.                     th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
  870.             } else if (!strcmp(parameter, "ttl")) {
  871.                 if (*p == '=') {
  872.                     char *end;
  873.                     p++;
  874.                     th->ttl = strtol(p, &end, 10);
  875.                     p = end;
  876.                 }
  877.             } else if (!strcmp(parameter, "destination")) {
  878.                 if (*p == '=') {
  879.                     p++;
  880.                     get_word_sep(buf, sizeof(buf), ";,", &p);
  881.                     get_sockaddr(buf, &th->destination);
  882.                 }
  883.             } else if (!strcmp(parameter, "source")) {
  884.                 if (*p == '=') {
  885.                     p++;
  886.                     get_word_sep(buf, sizeof(buf), ";,", &p);
  887.                     av_strlcpy(th->source, buf, sizeof(th->source));
  888.                 }
  889.             } else if (!strcmp(parameter, "mode")) {
  890.                 if (*p == '=') {
  891.                     p++;
  892.                     get_word_sep(buf, sizeof(buf), ";, ", &p);
  893.                     if (!strcmp(buf, "record") ||
  894.                         !strcmp(buf, "receive"))
  895.                         th->mode_record = 1;
  896.                 }
  897.             }
  898.  
  899.             while (*p != ';' && *p != '\0' && *p != ',')
  900.                 p++;
  901.             if (*p == ';')
  902.                 p++;
  903.         }
  904.         if (*p == ',')
  905.             p++;
  906.  
  907.         reply->nb_transports++;
  908.     }
  909. }
  910.  
  911. static void handle_rtp_info(RTSPState *rt, const char *url,
  912.                             uint32_t seq, uint32_t rtptime)
  913. {
  914.     int i;
  915.     if (!rtptime || !url[0])
  916.         return;
  917.     if (rt->transport != RTSP_TRANSPORT_RTP)
  918.         return;
  919.     for (i = 0; i < rt->nb_rtsp_streams; i++) {
  920.         RTSPStream *rtsp_st = rt->rtsp_streams[i];
  921.         RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
  922.         if (!rtpctx)
  923.             continue;
  924.         if (!strcmp(rtsp_st->control_url, url)) {
  925.             rtpctx->base_timestamp = rtptime;
  926.             break;
  927.         }
  928.     }
  929. }
  930.  
  931. static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
  932. {
  933.     int read = 0;
  934.     char key[20], value[1024], url[1024] = "";
  935.     uint32_t seq = 0, rtptime = 0;
  936.  
  937.     for (;;) {
  938.         p += strspn(p, SPACE_CHARS);
  939.         if (!*p)
  940.             break;
  941.         get_word_sep(key, sizeof(key), "=", &p);
  942.         if (*p != '=')
  943.             break;
  944.         p++;
  945.         get_word_sep(value, sizeof(value), ";, ", &p);
  946.         read++;
  947.         if (!strcmp(key, "url"))
  948.             av_strlcpy(url, value, sizeof(url));
  949.         else if (!strcmp(key, "seq"))
  950.             seq = strtoul(value, NULL, 10);
  951.         else if (!strcmp(key, "rtptime"))
  952.             rtptime = strtoul(value, NULL, 10);
  953.         if (*p == ',') {
  954.             handle_rtp_info(rt, url, seq, rtptime);
  955.             url[0] = '\0';
  956.             seq = rtptime = 0;
  957.             read = 0;
  958.         }
  959.         if (*p)
  960.             p++;
  961.     }
  962.     if (read > 0)
  963.         handle_rtp_info(rt, url, seq, rtptime);
  964. }
  965.  
  966. void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
  967.                         RTSPState *rt, const char *method)
  968. {
  969.     const char *p;
  970.  
  971.     /* NOTE: we do case independent match for broken servers */
  972.     p = buf;
  973.     if (av_stristart(p, "Session:", &p)) {
  974.         int t;
  975.         get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
  976.         if (av_stristart(p, ";timeout=", &p) &&
  977.             (t = strtol(p, NULL, 10)) > 0) {
  978.             reply->timeout = t;
  979.         }
  980.     } else if (av_stristart(p, "Content-Length:", &p)) {
  981.         reply->content_length = strtol(p, NULL, 10);
  982.     } else if (av_stristart(p, "Transport:", &p)) {
  983.         rtsp_parse_transport(reply, p);
  984.     } else if (av_stristart(p, "CSeq:", &p)) {
  985.         reply->seq = strtol(p, NULL, 10);
  986.     } else if (av_stristart(p, "Range:", &p)) {
  987.         rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
  988.     } else if (av_stristart(p, "RealChallenge1:", &p)) {
  989.         p += strspn(p, SPACE_CHARS);
  990.         av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
  991.     } else if (av_stristart(p, "Server:", &p)) {
  992.         p += strspn(p, SPACE_CHARS);
  993.         av_strlcpy(reply->server, p, sizeof(reply->server));
  994.     } else if (av_stristart(p, "Notice:", &p) ||
  995.                av_stristart(p, "X-Notice:", &p)) {
  996.         reply->notice = strtol(p, NULL, 10);
  997.     } else if (av_stristart(p, "Location:", &p)) {
  998.         p += strspn(p, SPACE_CHARS);
  999.         av_strlcpy(reply->location, p , sizeof(reply->location));
  1000.     } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
  1001.         p += strspn(p, SPACE_CHARS);
  1002.         ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
  1003.     } else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
  1004.         p += strspn(p, SPACE_CHARS);
  1005.         ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
  1006.     } else if (av_stristart(p, "Content-Base:", &p) && rt) {
  1007.         p += strspn(p, SPACE_CHARS);
  1008.         if (method && !strcmp(method, "DESCRIBE"))
  1009.             av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
  1010.     } else if (av_stristart(p, "RTP-Info:", &p) && rt) {
  1011.         p += strspn(p, SPACE_CHARS);
  1012.         if (method && !strcmp(method, "PLAY"))
  1013.             rtsp_parse_rtp_info(rt, p);
  1014.     } else if (av_stristart(p, "Public:", &p) && rt) {
  1015.         if (strstr(p, "GET_PARAMETER") &&
  1016.             method && !strcmp(method, "OPTIONS"))
  1017.             rt->get_parameter_supported = 1;
  1018.     } else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
  1019.         p += strspn(p, SPACE_CHARS);
  1020.         rt->accept_dynamic_rate = atoi(p);
  1021.     } else if (av_stristart(p, "Content-Type:", &p)) {
  1022.         p += strspn(p, SPACE_CHARS);
  1023.         av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
  1024.     }
  1025. }
  1026.  
  1027. /* skip a RTP/TCP interleaved packet */
  1028. void ff_rtsp_skip_packet(AVFormatContext *s)
  1029. {
  1030.     RTSPState *rt = s->priv_data;
  1031.     int ret, len, len1;
  1032.     uint8_t buf[1024];
  1033.  
  1034.     ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
  1035.     if (ret != 3)
  1036.         return;
  1037.     len = AV_RB16(buf + 1);
  1038.  
  1039.     av_dlog(s, "skipping RTP packet len=%d\n", len);
  1040.  
  1041.     /* skip payload */
  1042.     while (len > 0) {
  1043.         len1 = len;
  1044.         if (len1 > sizeof(buf))
  1045.             len1 = sizeof(buf);
  1046.         ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);
  1047.         if (ret != len1)
  1048.             return;
  1049.         len -= len1;
  1050.     }
  1051. }
  1052.  
  1053. int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
  1054.                        unsigned char **content_ptr,
  1055.                        int return_on_interleaved_data, const char *method)
  1056. {
  1057.     RTSPState *rt = s->priv_data;
  1058.     char buf[4096], buf1[1024], *q;
  1059.     unsigned char ch;
  1060.     const char *p;
  1061.     int ret, content_length, line_count = 0, request = 0;
  1062.     unsigned char *content = NULL;
  1063.  
  1064. start:
  1065.     line_count = 0;
  1066.     request = 0;
  1067.     content = NULL;
  1068.     memset(reply, 0, sizeof(*reply));
  1069.  
  1070.     /* parse reply (XXX: use buffers) */
  1071.     rt->last_reply[0] = '\0';
  1072.     for (;;) {
  1073.         q = buf;
  1074.         for (;;) {
  1075.             ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
  1076.             av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
  1077.             if (ret != 1)
  1078.                 return AVERROR_EOF;
  1079.             if (ch == '\n')
  1080.                 break;
  1081.             if (ch == '$') {
  1082.                 /* XXX: only parse it if first char on line ? */
  1083.                 if (return_on_interleaved_data) {
  1084.                     return 1;
  1085.                 } else
  1086.                     ff_rtsp_skip_packet(s);
  1087.             } else if (ch != '\r') {
  1088.                 if ((q - buf) < sizeof(buf) - 1)
  1089.                     *q++ = ch;
  1090.             }
  1091.         }
  1092.         *q = '\0';
  1093.  
  1094.         av_dlog(s, "line='%s'\n", buf);
  1095.  
  1096.         /* test if last line */
  1097.         if (buf[0] == '\0')
  1098.             break;
  1099.         p = buf;
  1100.         if (line_count == 0) {
  1101.             /* get reply code */
  1102.             get_word(buf1, sizeof(buf1), &p);
  1103.             if (!strncmp(buf1, "RTSP/", 5)) {
  1104.                 get_word(buf1, sizeof(buf1), &p);
  1105.                 reply->status_code = atoi(buf1);
  1106.                 av_strlcpy(reply->reason, p, sizeof(reply->reason));
  1107.             } else {
  1108.                 av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
  1109.                 get_word(buf1, sizeof(buf1), &p); // object
  1110.                 request = 1;
  1111.             }
  1112.         } else {
  1113.             ff_rtsp_parse_line(reply, p, rt, method);
  1114.             av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
  1115.             av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
  1116.         }
  1117.         line_count++;
  1118.     }
  1119.  
  1120.     if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
  1121.         av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
  1122.  
  1123.     content_length = reply->content_length;
  1124.     if (content_length > 0) {
  1125.         /* leave some room for a trailing '\0' (useful for simple parsing) */
  1126.         content = av_malloc(content_length + 1);
  1127.         ffurl_read_complete(rt->rtsp_hd, content, content_length);
  1128.         content[content_length] = '\0';
  1129.     }
  1130.     if (content_ptr)
  1131.         *content_ptr = content;
  1132.     else
  1133.         av_free(content);
  1134.  
  1135.     if (request) {
  1136.         char buf[1024];
  1137.         char base64buf[AV_BASE64_SIZE(sizeof(buf))];
  1138.         const char* ptr = buf;
  1139.  
  1140.         if (!strcmp(reply->reason, "OPTIONS")) {
  1141.             snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
  1142.             if (reply->seq)
  1143.                 av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
  1144.             if (reply->session_id[0])
  1145.                 av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
  1146.                                               reply->session_id);
  1147.         } else {
  1148.             snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
  1149.         }
  1150.         av_strlcat(buf, "\r\n", sizeof(buf));
  1151.  
  1152.         if (rt->control_transport == RTSP_MODE_TUNNEL) {
  1153.             av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
  1154.             ptr = base64buf;
  1155.         }
  1156.         ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
  1157.  
  1158.         rt->last_cmd_time = av_gettime();
  1159.         /* Even if the request from the server had data, it is not the data
  1160.          * that the caller wants or expects. The memory could also be leaked
  1161.          * if the actual following reply has content data. */
  1162.         if (content_ptr)
  1163.             av_freep(content_ptr);
  1164.         /* If method is set, this is called from ff_rtsp_send_cmd,
  1165.          * where a reply to exactly this request is awaited. For
  1166.          * callers from within packet receiving, we just want to
  1167.          * return to the caller and go back to receiving packets. */
  1168.         if (method)
  1169.             goto start;
  1170.         return 0;
  1171.     }
  1172.  
  1173.     if (rt->seq != reply->seq) {
  1174.         av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
  1175.             rt->seq, reply->seq);
  1176.     }
  1177.  
  1178.     /* EOS */
  1179.     if (reply->notice == 2101 /* End-of-Stream Reached */      ||
  1180.         reply->notice == 2104 /* Start-of-Stream Reached */    ||
  1181.         reply->notice == 2306 /* Continuous Feed Terminated */) {
  1182.         rt->state = RTSP_STATE_IDLE;
  1183.     } else if (reply->notice >= 4400 && reply->notice < 5500) {
  1184.         return AVERROR(EIO); /* data or server error */
  1185.     } else if (reply->notice == 2401 /* Ticket Expired */ ||
  1186.              (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
  1187.         return AVERROR(EPERM);
  1188.  
  1189.     return 0;
  1190. }
  1191.  
  1192. /**
  1193.  * Send a command to the RTSP server without waiting for the reply.
  1194.  *
  1195.  * @param s RTSP (de)muxer context
  1196.  * @param method the method for the request
  1197.  * @param url the target url for the request
  1198.  * @param headers extra header lines to include in the request
  1199.  * @param send_content if non-null, the data to send as request body content
  1200.  * @param send_content_length the length of the send_content data, or 0 if
  1201.  *                            send_content is null
  1202.  *
  1203.  * @return zero if success, nonzero otherwise
  1204.  */
  1205. static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
  1206.                                             const char *method, const char *url,
  1207.                                             const char *headers,
  1208.                                             const unsigned char *send_content,
  1209.                                             int send_content_length)
  1210. {
  1211.     RTSPState *rt = s->priv_data;
  1212.     char buf[4096], *out_buf;
  1213.     char base64buf[AV_BASE64_SIZE(sizeof(buf))];
  1214.  
  1215.     /* Add in RTSP headers */
  1216.     out_buf = buf;
  1217.     rt->seq++;
  1218.     snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
  1219.     if (headers)
  1220.         av_strlcat(buf, headers, sizeof(buf));
  1221.     av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
  1222.     av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n",  rt->user_agent);
  1223.     if (rt->session_id[0] != '\0' && (!headers ||
  1224.         !strstr(headers, "\nIf-Match:"))) {
  1225.         av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
  1226.     }
  1227.     if (rt->auth[0]) {
  1228.         char *str = ff_http_auth_create_response(&rt->auth_state,
  1229.                                                  rt->auth, url, method);
  1230.         if (str)
  1231.             av_strlcat(buf, str, sizeof(buf));
  1232.         av_free(str);
  1233.     }
  1234.     if (send_content_length > 0 && send_content)
  1235.         av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
  1236.     av_strlcat(buf, "\r\n", sizeof(buf));
  1237.  
  1238.     /* base64 encode rtsp if tunneling */
  1239.     if (rt->control_transport == RTSP_MODE_TUNNEL) {
  1240.         av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
  1241.         out_buf = base64buf;
  1242.     }
  1243.  
  1244.     av_dlog(s, "Sending:\n%s--\n", buf);
  1245.  
  1246.     ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
  1247.     if (send_content_length > 0 && send_content) {
  1248.         if (rt->control_transport == RTSP_MODE_TUNNEL) {
  1249.             av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
  1250.                                     "with content data not supported\n");
  1251.             return AVERROR_PATCHWELCOME;
  1252.         }
  1253.         ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
  1254.     }
  1255.     rt->last_cmd_time = av_gettime();
  1256.  
  1257.     return 0;
  1258. }
  1259.  
  1260. int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
  1261.                            const char *url, const char *headers)
  1262. {
  1263.     return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
  1264. }
  1265.  
  1266. int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
  1267.                      const char *headers, RTSPMessageHeader *reply,
  1268.                      unsigned char **content_ptr)
  1269. {
  1270.     return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
  1271.                                          content_ptr, NULL, 0);
  1272. }
  1273.  
  1274. int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
  1275.                                   const char *method, const char *url,
  1276.                                   const char *header,
  1277.                                   RTSPMessageHeader *reply,
  1278.                                   unsigned char **content_ptr,
  1279.                                   const unsigned char *send_content,
  1280.                                   int send_content_length)
  1281. {
  1282.     RTSPState *rt = s->priv_data;
  1283.     HTTPAuthType cur_auth_type;
  1284.     int ret, attempts = 0;
  1285.  
  1286. retry:
  1287.     cur_auth_type = rt->auth_state.auth_type;
  1288.     if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
  1289.                                                 send_content,
  1290.                                                 send_content_length)))
  1291.         return ret;
  1292.  
  1293.     if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
  1294.         return ret;
  1295.     attempts++;
  1296.  
  1297.     if (reply->status_code == 401 &&
  1298.         (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
  1299.         rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
  1300.         goto retry;
  1301.  
  1302.     if (reply->status_code > 400){
  1303.         av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
  1304.                method,
  1305.                reply->status_code,
  1306.                reply->reason);
  1307.         av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
  1308.     }
  1309.  
  1310.     return 0;
  1311. }
  1312.  
  1313. int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
  1314.                               int lower_transport, const char *real_challenge)
  1315. {
  1316.     RTSPState *rt = s->priv_data;
  1317.     int rtx = 0, j, i, err, interleave = 0, port_off;
  1318.     RTSPStream *rtsp_st;
  1319.     RTSPMessageHeader reply1, *reply = &reply1;
  1320.     char cmd[2048];
  1321.     const char *trans_pref;
  1322.  
  1323.     if (rt->transport == RTSP_TRANSPORT_RDT)
  1324.         trans_pref = "x-pn-tng";
  1325.     else if (rt->transport == RTSP_TRANSPORT_RAW)
  1326.         trans_pref = "RAW/RAW";
  1327.     else
  1328.         trans_pref = "RTP/AVP";
  1329.  
  1330.     /* default timeout: 1 minute */
  1331.     rt->timeout = 60;
  1332.  
  1333.     /* Choose a random starting offset within the first half of the
  1334.      * port range, to allow for a number of ports to try even if the offset
  1335.      * happens to be at the end of the random range. */
  1336.     port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
  1337.     /* even random offset */
  1338.     port_off -= port_off & 0x01;
  1339.  
  1340.     for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
  1341.         char transport[2048];
  1342.  
  1343.         /*
  1344.          * WMS serves all UDP data over a single connection, the RTX, which
  1345.          * isn't necessarily the first in the SDP but has to be the first
  1346.          * to be set up, else the second/third SETUP will fail with a 461.
  1347.          */
  1348.         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
  1349.              rt->server_type == RTSP_SERVER_WMS) {
  1350.             if (i == 0) {
  1351.                 /* rtx first */
  1352.                 for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
  1353.                     int len = strlen(rt->rtsp_streams[rtx]->control_url);
  1354.                     if (len >= 4 &&
  1355.                         !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
  1356.                                 "/rtx"))
  1357.                         break;
  1358.                 }
  1359.                 if (rtx == rt->nb_rtsp_streams)
  1360.                     return -1; /* no RTX found */
  1361.                 rtsp_st = rt->rtsp_streams[rtx];
  1362.             } else
  1363.                 rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
  1364.         } else
  1365.             rtsp_st = rt->rtsp_streams[i];
  1366.  
  1367.         /* RTP/UDP */
  1368.         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
  1369.             char buf[256];
  1370.  
  1371.             if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
  1372.                 port = reply->transports[0].client_port_min;
  1373.                 goto have_port;
  1374.             }
  1375.  
  1376.             /* first try in specified port range */
  1377.             while (j <= rt->rtp_port_max) {
  1378.                 ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
  1379.                             "?localport=%d", j);
  1380.                 /* we will use two ports per rtp stream (rtp and rtcp) */
  1381.                 j += 2;
  1382.                 if (!ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
  1383.                                &s->interrupt_callback, NULL))
  1384.                     goto rtp_opened;
  1385.             }
  1386.             av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
  1387.             err = AVERROR(EIO);
  1388.             goto fail;
  1389.  
  1390.         rtp_opened:
  1391.             port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
  1392.         have_port:
  1393.             snprintf(transport, sizeof(transport) - 1,
  1394.                      "%s/UDP;", trans_pref);
  1395.             if (rt->server_type != RTSP_SERVER_REAL)
  1396.                 av_strlcat(transport, "unicast;", sizeof(transport));
  1397.             av_strlcatf(transport, sizeof(transport),
  1398.                      "client_port=%d", port);
  1399.             if (rt->transport == RTSP_TRANSPORT_RTP &&
  1400.                 !(rt->server_type == RTSP_SERVER_WMS && i > 0))
  1401.                 av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
  1402.         }
  1403.  
  1404.         /* RTP/TCP */
  1405.         else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
  1406.             /* For WMS streams, the application streams are only used for
  1407.              * UDP. When trying to set it up for TCP streams, the server
  1408.              * will return an error. Therefore, we skip those streams. */
  1409.             if (rt->server_type == RTSP_SERVER_WMS &&
  1410.                 (rtsp_st->stream_index < 0 ||
  1411.                  s->streams[rtsp_st->stream_index]->codec->codec_type ==
  1412.                     AVMEDIA_TYPE_DATA))
  1413.                 continue;
  1414.             snprintf(transport, sizeof(transport) - 1,
  1415.                      "%s/TCP;", trans_pref);
  1416.             if (rt->transport != RTSP_TRANSPORT_RDT)
  1417.                 av_strlcat(transport, "unicast;", sizeof(transport));
  1418.             av_strlcatf(transport, sizeof(transport),
  1419.                         "interleaved=%d-%d",
  1420.                         interleave, interleave + 1);
  1421.             interleave += 2;
  1422.         }
  1423.  
  1424.         else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
  1425.             snprintf(transport, sizeof(transport) - 1,
  1426.                      "%s/UDP;multicast", trans_pref);
  1427.         }
  1428.         if (s->oformat) {
  1429.             av_strlcat(transport, ";mode=record", sizeof(transport));
  1430.         } else if (rt->server_type == RTSP_SERVER_REAL ||
  1431.                    rt->server_type == RTSP_SERVER_WMS)
  1432.             av_strlcat(transport, ";mode=play", sizeof(transport));
  1433.         snprintf(cmd, sizeof(cmd),
  1434.                  "Transport: %s\r\n",
  1435.                  transport);
  1436.         if (rt->accept_dynamic_rate)
  1437.             av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
  1438.         if (i == 0 && rt->server_type == RTSP_SERVER_REAL && CONFIG_RTPDEC) {
  1439.             char real_res[41], real_csum[9];
  1440.             ff_rdt_calc_response_and_checksum(real_res, real_csum,
  1441.                                               real_challenge);
  1442.             av_strlcatf(cmd, sizeof(cmd),
  1443.                         "If-Match: %s\r\n"
  1444.                         "RealChallenge2: %s, sd=%s\r\n",
  1445.                         rt->session_id, real_res, real_csum);
  1446.         }
  1447.         ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
  1448.         if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
  1449.             err = 1;
  1450.             goto fail;
  1451.         } else if (reply->status_code != RTSP_STATUS_OK ||
  1452.                    reply->nb_transports != 1) {
  1453.             err = AVERROR_INVALIDDATA;
  1454.             goto fail;
  1455.         }
  1456.  
  1457.         /* XXX: same protocol for all streams is required */
  1458.         if (i > 0) {
  1459.             if (reply->transports[0].lower_transport != rt->lower_transport ||
  1460.                 reply->transports[0].transport != rt->transport) {
  1461.                 err = AVERROR_INVALIDDATA;
  1462.                 goto fail;
  1463.             }
  1464.         } else {
  1465.             rt->lower_transport = reply->transports[0].lower_transport;
  1466.             rt->transport = reply->transports[0].transport;
  1467.         }
  1468.  
  1469.         /* Fail if the server responded with another lower transport mode
  1470.          * than what we requested. */
  1471.         if (reply->transports[0].lower_transport != lower_transport) {
  1472.             av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
  1473.             err = AVERROR_INVALIDDATA;
  1474.             goto fail;
  1475.         }
  1476.  
  1477.         switch(reply->transports[0].lower_transport) {
  1478.         case RTSP_LOWER_TRANSPORT_TCP:
  1479.             rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
  1480.             rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
  1481.             break;
  1482.  
  1483.         case RTSP_LOWER_TRANSPORT_UDP: {
  1484.             char url[1024], options[30] = "";
  1485.             const char *peer = host;
  1486.  
  1487.             if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
  1488.                 av_strlcpy(options, "?connect=1", sizeof(options));
  1489.             /* Use source address if specified */
  1490.             if (reply->transports[0].source[0])
  1491.                 peer = reply->transports[0].source;
  1492.             ff_url_join(url, sizeof(url), "rtp", NULL, peer,
  1493.                         reply->transports[0].server_port_min, "%s", options);
  1494.             if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
  1495.                 ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
  1496.                 err = AVERROR_INVALIDDATA;
  1497.                 goto fail;
  1498.             }
  1499.             /* Try to initialize the connection state in a
  1500.              * potential NAT router by sending dummy packets.
  1501.              * RTP/RTCP dummy packets are used for RDT, too.
  1502.              */
  1503.             if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat &&
  1504.                 CONFIG_RTPDEC)
  1505.                 ff_rtp_send_punch_packets(rtsp_st->rtp_handle);
  1506.             break;
  1507.         }
  1508.         case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
  1509.             char url[1024], namebuf[50], optbuf[20] = "";
  1510.             struct sockaddr_storage addr;
  1511.             int port, ttl;
  1512.  
  1513.             if (reply->transports[0].destination.ss_family) {
  1514.                 addr      = reply->transports[0].destination;
  1515.                 port      = reply->transports[0].port_min;
  1516.                 ttl       = reply->transports[0].ttl;
  1517.             } else {
  1518.                 addr      = rtsp_st->sdp_ip;
  1519.                 port      = rtsp_st->sdp_port;
  1520.                 ttl       = rtsp_st->sdp_ttl;
  1521.             }
  1522.             if (ttl > 0)
  1523.                 snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
  1524.             getnameinfo((struct sockaddr*) &addr, sizeof(addr),
  1525.                         namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
  1526.             ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
  1527.                         port, "%s", optbuf);
  1528.             if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
  1529.                            &s->interrupt_callback, NULL) < 0) {
  1530.                 err = AVERROR_INVALIDDATA;
  1531.                 goto fail;
  1532.             }
  1533.             break;
  1534.         }
  1535.         }
  1536.  
  1537.         if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
  1538.             goto fail;
  1539.     }
  1540.  
  1541.     if (rt->nb_rtsp_streams && reply->timeout > 0)
  1542.         rt->timeout = reply->timeout;
  1543.  
  1544.     if (rt->server_type == RTSP_SERVER_REAL)
  1545.         rt->need_subscription = 1;
  1546.  
  1547.     return 0;
  1548.  
  1549. fail:
  1550.     ff_rtsp_undo_setup(s);
  1551.     return err;
  1552. }
  1553.  
  1554. void ff_rtsp_close_connections(AVFormatContext *s)
  1555. {
  1556.     RTSPState *rt = s->priv_data;
  1557.     if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out);
  1558.     ffurl_close(rt->rtsp_hd);
  1559.     rt->rtsp_hd = rt->rtsp_hd_out = NULL;
  1560. }
  1561.  
  1562. int ff_rtsp_connect(AVFormatContext *s)
  1563. {
  1564.     RTSPState *rt = s->priv_data;
  1565.     char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
  1566.     int port, err, tcp_fd;
  1567.     RTSPMessageHeader reply1 = {0}, *reply = &reply1;
  1568.     int lower_transport_mask = 0;
  1569.     char real_challenge[64] = "";
  1570.     struct sockaddr_storage peer;
  1571.     socklen_t peer_len = sizeof(peer);
  1572.  
  1573.     if (rt->rtp_port_max < rt->rtp_port_min) {
  1574.         av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
  1575.                                 "than min port %d\n", rt->rtp_port_max,
  1576.                                                       rt->rtp_port_min);
  1577.         return AVERROR(EINVAL);
  1578.     }
  1579.  
  1580.     if (!ff_network_init())
  1581.         return AVERROR(EIO);
  1582.  
  1583.     if (s->max_delay < 0) /* Not set by the caller */
  1584.         s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
  1585.  
  1586.     rt->control_transport = RTSP_MODE_PLAIN;
  1587.     if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) {
  1588.         rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
  1589.         rt->control_transport = RTSP_MODE_TUNNEL;
  1590.     }
  1591.     /* Only pass through valid flags from here */
  1592.     rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
  1593.  
  1594. redirect:
  1595.     lower_transport_mask = rt->lower_transport_mask;
  1596.     /* extract hostname and port */
  1597.     av_url_split(NULL, 0, auth, sizeof(auth),
  1598.                  host, sizeof(host), &port, path, sizeof(path), s->filename);
  1599.     if (*auth) {
  1600.         av_strlcpy(rt->auth, auth, sizeof(rt->auth));
  1601.     }
  1602.     if (port < 0)
  1603.         port = RTSP_DEFAULT_PORT;
  1604.  
  1605.     if (!lower_transport_mask)
  1606.         lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
  1607.  
  1608.     if (s->oformat) {
  1609.         /* Only UDP or TCP - UDP multicast isn't supported. */
  1610.         lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
  1611.                                 (1 << RTSP_LOWER_TRANSPORT_TCP);
  1612.         if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
  1613.             av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
  1614.                                     "only UDP and TCP are supported for output.\n");
  1615.             err = AVERROR(EINVAL);
  1616.             goto fail;
  1617.         }
  1618.     }
  1619.  
  1620.     /* Construct the URI used in request; this is similar to s->filename,
  1621.      * but with authentication credentials removed and RTSP specific options
  1622.      * stripped out. */
  1623.     ff_url_join(rt->control_uri, sizeof(rt->control_uri), "rtsp", NULL,
  1624.                 host, port, "%s", path);
  1625.  
  1626.     if (rt->control_transport == RTSP_MODE_TUNNEL) {
  1627.         /* set up initial handshake for tunneling */
  1628.         char httpname[1024];
  1629.         char sessioncookie[17];
  1630.         char headers[1024];
  1631.  
  1632.         ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
  1633.         snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
  1634.                  av_get_random_seed(), av_get_random_seed());
  1635.  
  1636.         /* GET requests */
  1637.         if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
  1638.                         &s->interrupt_callback) < 0) {
  1639.             err = AVERROR(EIO);
  1640.             goto fail;
  1641.         }
  1642.  
  1643.         /* generate GET headers */
  1644.         snprintf(headers, sizeof(headers),
  1645.                  "x-sessioncookie: %s\r\n"
  1646.                  "Accept: application/x-rtsp-tunnelled\r\n"
  1647.                  "Pragma: no-cache\r\n"
  1648.                  "Cache-Control: no-cache\r\n",
  1649.                  sessioncookie);
  1650.         av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
  1651.  
  1652.         /* complete the connection */
  1653.         if (ffurl_connect(rt->rtsp_hd, NULL)) {
  1654.             err = AVERROR(EIO);
  1655.             goto fail;
  1656.         }
  1657.  
  1658.         /* POST requests */
  1659.         if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
  1660.                         &s->interrupt_callback) < 0 ) {
  1661.             err = AVERROR(EIO);
  1662.             goto fail;
  1663.         }
  1664.  
  1665.         /* generate POST headers */
  1666.         snprintf(headers, sizeof(headers),
  1667.                  "x-sessioncookie: %s\r\n"
  1668.                  "Content-Type: application/x-rtsp-tunnelled\r\n"
  1669.                  "Pragma: no-cache\r\n"
  1670.                  "Cache-Control: no-cache\r\n"
  1671.                  "Content-Length: 32767\r\n"
  1672.                  "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
  1673.                  sessioncookie);
  1674.         av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
  1675.         av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
  1676.  
  1677.         /* Initialize the authentication state for the POST session. The HTTP
  1678.          * protocol implementation doesn't properly handle multi-pass
  1679.          * authentication for POST requests, since it would require one of
  1680.          * the following:
  1681.          * - implementing Expect: 100-continue, which many HTTP servers
  1682.          *   don't support anyway, even less the RTSP servers that do HTTP
  1683.          *   tunneling
  1684.          * - sending the whole POST data until getting a 401 reply specifying
  1685.          *   what authentication method to use, then resending all that data
  1686.          * - waiting for potential 401 replies directly after sending the
  1687.          *   POST header (waiting for some unspecified time)
  1688.          * Therefore, we copy the full auth state, which works for both basic
  1689.          * and digest. (For digest, we would have to synchronize the nonce
  1690.          * count variable between the two sessions, if we'd do more requests
  1691.          * with the original session, though.)
  1692.          */
  1693.         ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
  1694.  
  1695.         /* complete the connection */
  1696.         if (ffurl_connect(rt->rtsp_hd_out, NULL)) {
  1697.             err = AVERROR(EIO);
  1698.             goto fail;
  1699.         }
  1700.     } else {
  1701.         /* open the tcp connection */
  1702.         ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port,
  1703.                     "?timeout=%d", rt->stimeout);
  1704.         if (ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
  1705.                        &s->interrupt_callback, NULL) < 0) {
  1706.             err = AVERROR(EIO);
  1707.             goto fail;
  1708.         }
  1709.         rt->rtsp_hd_out = rt->rtsp_hd;
  1710.     }
  1711.     rt->seq = 0;
  1712.  
  1713.     tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
  1714.     if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
  1715.         getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
  1716.                     NULL, 0, NI_NUMERICHOST);
  1717.     }
  1718.  
  1719.     /* request options supported by the server; this also detects server
  1720.      * type */
  1721.     for (rt->server_type = RTSP_SERVER_RTP;;) {
  1722.         cmd[0] = 0;
  1723.         if (rt->server_type == RTSP_SERVER_REAL)
  1724.             av_strlcat(cmd,
  1725.                        /*
  1726.                         * The following entries are required for proper
  1727.                         * streaming from a Realmedia server. They are
  1728.                         * interdependent in some way although we currently
  1729.                         * don't quite understand how. Values were copied
  1730.                         * from mplayer SVN r23589.
  1731.                         *   ClientChallenge is a 16-byte ID in hex
  1732.                         *   CompanyID is a 16-byte ID in base64
  1733.                         */
  1734.                        "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
  1735.                        "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
  1736.                        "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
  1737.                        "GUID: 00000000-0000-0000-0000-000000000000\r\n",
  1738.                        sizeof(cmd));
  1739.         ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
  1740.         if (reply->status_code != RTSP_STATUS_OK) {
  1741.             err = AVERROR_INVALIDDATA;
  1742.             goto fail;
  1743.         }
  1744.  
  1745.         /* detect server type if not standard-compliant RTP */
  1746.         if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
  1747.             rt->server_type = RTSP_SERVER_REAL;
  1748.             continue;
  1749.         } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
  1750.             rt->server_type = RTSP_SERVER_WMS;
  1751.         } else if (rt->server_type == RTSP_SERVER_REAL)
  1752.             strcpy(real_challenge, reply->real_challenge);
  1753.         break;
  1754.     }
  1755.  
  1756.     if (s->iformat && CONFIG_RTSP_DEMUXER)
  1757.         err = ff_rtsp_setup_input_streams(s, reply);
  1758.     else if (CONFIG_RTSP_MUXER)
  1759.         err = ff_rtsp_setup_output_streams(s, host);
  1760.     if (err)
  1761.         goto fail;
  1762.  
  1763.     do {
  1764.         int lower_transport = ff_log2_tab[lower_transport_mask &
  1765.                                   ~(lower_transport_mask - 1)];
  1766.  
  1767.         err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
  1768.                                  rt->server_type == RTSP_SERVER_REAL ?
  1769.                                      real_challenge : NULL);
  1770.         if (err < 0)
  1771.             goto fail;
  1772.         lower_transport_mask &= ~(1 << lower_transport);
  1773.         if (lower_transport_mask == 0 && err == 1) {
  1774.             err = AVERROR(EPROTONOSUPPORT);
  1775.             goto fail;
  1776.         }
  1777.     } while (err);
  1778.  
  1779.     rt->lower_transport_mask = lower_transport_mask;
  1780.     av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
  1781.     rt->state = RTSP_STATE_IDLE;
  1782.     rt->seek_timestamp = 0; /* default is to start stream at position zero */
  1783.     return 0;
  1784.  fail:
  1785.     ff_rtsp_close_streams(s);
  1786.     ff_rtsp_close_connections(s);
  1787.     if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
  1788.         av_strlcpy(s->filename, reply->location, sizeof(s->filename));
  1789.         av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
  1790.                reply->status_code,
  1791.                s->filename);
  1792.         goto redirect;
  1793.     }
  1794.     ff_network_close();
  1795.     return err;
  1796. }
  1797. #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
  1798.  
  1799. #if CONFIG_RTPDEC
  1800. static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
  1801.                            uint8_t *buf, int buf_size, int64_t wait_end)
  1802. {
  1803.     RTSPState *rt = s->priv_data;
  1804.     RTSPStream *rtsp_st;
  1805.     int n, i, ret, tcp_fd, timeout_cnt = 0;
  1806.     int max_p = 0;
  1807.     struct pollfd *p = rt->p;
  1808.     int *fds = NULL, fdsnum, fdsidx;
  1809.  
  1810.     for (;;) {
  1811.         if (ff_check_interrupt(&s->interrupt_callback))
  1812.             return AVERROR_EXIT;
  1813.         if (wait_end && wait_end - av_gettime() < 0)
  1814.             return AVERROR(EAGAIN);
  1815.         max_p = 0;
  1816.         if (rt->rtsp_hd) {
  1817.             tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
  1818.             p[max_p].fd = tcp_fd;
  1819.             p[max_p++].events = POLLIN;
  1820.         } else {
  1821.             tcp_fd = -1;
  1822.         }
  1823.         for (i = 0; i < rt->nb_rtsp_streams; i++) {
  1824.             rtsp_st = rt->rtsp_streams[i];
  1825.             if (rtsp_st->rtp_handle) {
  1826.                 if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
  1827.                                                       &fds, &fdsnum)) {
  1828.                     av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
  1829.                     return ret;
  1830.                 }
  1831.                 if (fdsnum != 2) {
  1832.                     av_log(s, AV_LOG_ERROR,
  1833.                            "Number of fds %d not supported\n", fdsnum);
  1834.                     return AVERROR_INVALIDDATA;
  1835.                 }
  1836.                 for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
  1837.                     p[max_p].fd       = fds[fdsidx];
  1838.                     p[max_p++].events = POLLIN;
  1839.                 }
  1840.                 av_free(fds);
  1841.             }
  1842.         }
  1843.         n = poll(p, max_p, POLL_TIMEOUT_MS);
  1844.         if (n > 0) {
  1845.             int j = 1 - (tcp_fd == -1);
  1846.             timeout_cnt = 0;
  1847.             for (i = 0; i < rt->nb_rtsp_streams; i++) {
  1848.                 rtsp_st = rt->rtsp_streams[i];
  1849.                 if (rtsp_st->rtp_handle) {
  1850.                     if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
  1851.                         ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
  1852.                         if (ret > 0) {
  1853.                             *prtsp_st = rtsp_st;
  1854.                             return ret;
  1855.                         }
  1856.                     }
  1857.                     j+=2;
  1858.                 }
  1859.             }
  1860. #if CONFIG_RTSP_DEMUXER
  1861.             if (tcp_fd != -1 && p[0].revents & POLLIN) {
  1862.                 if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
  1863.                     if (rt->state == RTSP_STATE_STREAMING) {
  1864.                         if (!ff_rtsp_parse_streaming_commands(s))
  1865.                             return AVERROR_EOF;
  1866.                         else
  1867.                             av_log(s, AV_LOG_WARNING,
  1868.                                    "Unable to answer to TEARDOWN\n");
  1869.                     } else
  1870.                         return 0;
  1871.                 } else {
  1872.                     RTSPMessageHeader reply;
  1873.                     ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
  1874.                     if (ret < 0)
  1875.                         return ret;
  1876.                     /* XXX: parse message */
  1877.                     if (rt->state != RTSP_STATE_STREAMING)
  1878.                         return 0;
  1879.                 }
  1880.             }
  1881. #endif
  1882.         } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
  1883.             return AVERROR(ETIMEDOUT);
  1884.         } else if (n < 0 && errno != EINTR)
  1885.             return AVERROR(errno);
  1886.     }
  1887. }
  1888.  
  1889. static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
  1890.                        const uint8_t *buf, int len)
  1891. {
  1892.     RTSPState *rt = s->priv_data;
  1893.     int i;
  1894.     if (len < 0)
  1895.         return len;
  1896.     if (rt->nb_rtsp_streams == 1) {
  1897.         *rtsp_st = rt->rtsp_streams[0];
  1898.         return len;
  1899.     }
  1900.     if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
  1901.         if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
  1902.             int no_ssrc = 0;
  1903.             for (i = 0; i < rt->nb_rtsp_streams; i++) {
  1904.                 RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
  1905.                 if (!rtpctx)
  1906.                     continue;
  1907.                 if (rtpctx->ssrc == AV_RB32(&buf[4])) {
  1908.                     *rtsp_st = rt->rtsp_streams[i];
  1909.                     return len;
  1910.                 }
  1911.                 if (!rtpctx->ssrc)
  1912.                     no_ssrc = 1;
  1913.             }
  1914.             if (no_ssrc) {
  1915.                 av_log(s, AV_LOG_WARNING,
  1916.                        "Unable to pick stream for packet - SSRC not known for "
  1917.                        "all streams\n");
  1918.                 return AVERROR(EAGAIN);
  1919.             }
  1920.         } else {
  1921.             for (i = 0; i < rt->nb_rtsp_streams; i++) {
  1922.                 if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
  1923.                     *rtsp_st = rt->rtsp_streams[i];
  1924.                     return len;
  1925.                 }
  1926.             }
  1927.         }
  1928.     }
  1929.     av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
  1930.     return AVERROR(EAGAIN);
  1931. }
  1932.  
  1933. int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
  1934. {
  1935.     RTSPState *rt = s->priv_data;
  1936.     int ret, len;
  1937.     RTSPStream *rtsp_st, *first_queue_st = NULL;
  1938.     int64_t wait_end = 0;
  1939.  
  1940.     if (rt->nb_byes == rt->nb_rtsp_streams)
  1941.         return AVERROR_EOF;
  1942.  
  1943.     /* get next frames from the same RTP packet */
  1944.     if (rt->cur_transport_priv) {
  1945.         if (rt->transport == RTSP_TRANSPORT_RDT) {
  1946.             ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
  1947.         } else if (rt->transport == RTSP_TRANSPORT_RTP) {
  1948.             ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
  1949.         } else if (rt->ts && CONFIG_RTPDEC) {
  1950.             ret = ff_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
  1951.             if (ret >= 0) {
  1952.                 rt->recvbuf_pos += ret;
  1953.                 ret = rt->recvbuf_pos < rt->recvbuf_len;
  1954.             }
  1955.         } else
  1956.             ret = -1;
  1957.         if (ret == 0) {
  1958.             rt->cur_transport_priv = NULL;
  1959.             return 0;
  1960.         } else if (ret == 1) {
  1961.             return 0;
  1962.         } else
  1963.             rt->cur_transport_priv = NULL;
  1964.     }
  1965.  
  1966. redo:
  1967.     if (rt->transport == RTSP_TRANSPORT_RTP) {
  1968.         int i;
  1969.         int64_t first_queue_time = 0;
  1970.         for (i = 0; i < rt->nb_rtsp_streams; i++) {
  1971.             RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
  1972.             int64_t queue_time;
  1973.             if (!rtpctx)
  1974.                 continue;
  1975.             queue_time = ff_rtp_queued_packet_time(rtpctx);
  1976.             if (queue_time && (queue_time - first_queue_time < 0 ||
  1977.                                !first_queue_time)) {
  1978.                 first_queue_time = queue_time;
  1979.                 first_queue_st   = rt->rtsp_streams[i];
  1980.             }
  1981.         }
  1982.         if (first_queue_time) {
  1983.             wait_end = first_queue_time + s->max_delay;
  1984.         } else {
  1985.             wait_end = 0;
  1986.             first_queue_st = NULL;
  1987.         }
  1988.     }
  1989.  
  1990.     /* read next RTP packet */
  1991.     if (!rt->recvbuf) {
  1992.         rt->recvbuf = av_malloc(RECVBUF_SIZE);
  1993.         if (!rt->recvbuf)
  1994.             return AVERROR(ENOMEM);
  1995.     }
  1996.  
  1997.     switch(rt->lower_transport) {
  1998.     default:
  1999. #if CONFIG_RTSP_DEMUXER
  2000.     case RTSP_LOWER_TRANSPORT_TCP:
  2001.         len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
  2002.         break;
  2003. #endif
  2004.     case RTSP_LOWER_TRANSPORT_UDP:
  2005.     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
  2006.         len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
  2007.         if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
  2008.             ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);
  2009.         break;
  2010.     case RTSP_LOWER_TRANSPORT_CUSTOM:
  2011.         if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
  2012.             wait_end && wait_end < av_gettime())
  2013.             len = AVERROR(EAGAIN);
  2014.         else
  2015.             len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
  2016.         len = pick_stream(s, &rtsp_st, rt->recvbuf, len);
  2017.         if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
  2018.             ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len);
  2019.         break;
  2020.     }
  2021.     if (len == AVERROR(EAGAIN) && first_queue_st &&
  2022.         rt->transport == RTSP_TRANSPORT_RTP) {
  2023.         rtsp_st = first_queue_st;
  2024.         ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
  2025.         goto end;
  2026.     }
  2027.     if (len < 0)
  2028.         return len;
  2029.     if (len == 0)
  2030.         return AVERROR_EOF;
  2031.     if (rt->transport == RTSP_TRANSPORT_RDT) {
  2032.         ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
  2033.     } else if (rt->transport == RTSP_TRANSPORT_RTP) {
  2034.         ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
  2035.         if (rtsp_st->feedback) {
  2036.             AVIOContext *pb = NULL;
  2037.             if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)
  2038.                 pb = s->pb;
  2039.             ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
  2040.         }
  2041.         if (ret < 0) {
  2042.             /* Either bad packet, or a RTCP packet. Check if the
  2043.              * first_rtcp_ntp_time field was initialized. */
  2044.             RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
  2045.             if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
  2046.                 /* first_rtcp_ntp_time has been initialized for this stream,
  2047.                  * copy the same value to all other uninitialized streams,
  2048.                  * in order to map their timestamp origin to the same ntp time
  2049.                  * as this one. */
  2050.                 int i;
  2051.                 AVStream *st = NULL;
  2052.                 if (rtsp_st->stream_index >= 0)
  2053.                     st = s->streams[rtsp_st->stream_index];
  2054.                 for (i = 0; i < rt->nb_rtsp_streams; i++) {
  2055.                     RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
  2056.                     AVStream *st2 = NULL;
  2057.                     if (rt->rtsp_streams[i]->stream_index >= 0)
  2058.                         st2 = s->streams[rt->rtsp_streams[i]->stream_index];
  2059.                     if (rtpctx2 && st && st2 &&
  2060.                         rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
  2061.                         rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
  2062.                         rtpctx2->rtcp_ts_offset = av_rescale_q(
  2063.                             rtpctx->rtcp_ts_offset, st->time_base,
  2064.                             st2->time_base);
  2065.                     }
  2066.                 }
  2067.             }
  2068.             if (ret == -RTCP_BYE) {
  2069.                 rt->nb_byes++;
  2070.  
  2071.                 av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
  2072.                        rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
  2073.  
  2074.                 if (rt->nb_byes == rt->nb_rtsp_streams)
  2075.                     return AVERROR_EOF;
  2076.             }
  2077.         }
  2078.     } else if (rt->ts && CONFIG_RTPDEC) {
  2079.         ret = ff_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
  2080.         if (ret >= 0) {
  2081.             if (ret < len) {
  2082.                 rt->recvbuf_len = len;
  2083.                 rt->recvbuf_pos = ret;
  2084.                 rt->cur_transport_priv = rt->ts;
  2085.                 return 1;
  2086.             } else {
  2087.                 ret = 0;
  2088.             }
  2089.         }
  2090.     } else {
  2091.         return AVERROR_INVALIDDATA;
  2092.     }
  2093. end:
  2094.     if (ret < 0)
  2095.         goto redo;
  2096.     if (ret == 1)
  2097.         /* more packets may follow, so we save the RTP context */
  2098.         rt->cur_transport_priv = rtsp_st->transport_priv;
  2099.  
  2100.     return ret;
  2101. }
  2102. #endif /* CONFIG_RTPDEC */
  2103.  
  2104. #if CONFIG_SDP_DEMUXER
  2105. static int sdp_probe(AVProbeData *p1)
  2106. {
  2107.     const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
  2108.  
  2109.     /* we look for a line beginning "c=IN IP" */
  2110.     while (p < p_end && *p != '\0') {
  2111.         if (p + sizeof("c=IN IP") - 1 < p_end &&
  2112.             av_strstart(p, "c=IN IP", NULL))
  2113.             return AVPROBE_SCORE_EXTENSION;
  2114.  
  2115.         while (p < p_end - 1 && *p != '\n') p++;
  2116.         if (++p >= p_end)
  2117.             break;
  2118.         if (*p == '\r')
  2119.             p++;
  2120.     }
  2121.     return 0;
  2122. }
  2123.  
  2124. static void append_source_addrs(char *buf, int size, const char *name,
  2125.                                 int count, struct RTSPSource **addrs)
  2126. {
  2127.     int i;
  2128.     if (!count)
  2129.         return;
  2130.     av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
  2131.     for (i = 1; i < count; i++)
  2132.         av_strlcatf(buf, size, ",%s", addrs[i]->addr);
  2133. }
  2134.  
  2135. static int sdp_read_header(AVFormatContext *s)
  2136. {
  2137.     RTSPState *rt = s->priv_data;
  2138.     RTSPStream *rtsp_st;
  2139.     int size, i, err;
  2140.     char *content;
  2141.     char url[1024];
  2142.  
  2143.     if (!ff_network_init())
  2144.         return AVERROR(EIO);
  2145.  
  2146.     if (s->max_delay < 0) /* Not set by the caller */
  2147.         s->max_delay = DEFAULT_REORDERING_DELAY;
  2148.     if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
  2149.         rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;
  2150.  
  2151.     /* read the whole sdp file */
  2152.     /* XXX: better loading */
  2153.     content = av_malloc(SDP_MAX_SIZE);
  2154.     size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);
  2155.     if (size <= 0) {
  2156.         av_free(content);
  2157.         return AVERROR_INVALIDDATA;
  2158.     }
  2159.     content[size] ='\0';
  2160.  
  2161.     err = ff_sdp_parse(s, content);
  2162.     av_free(content);
  2163.     if (err) goto fail;
  2164.  
  2165.     /* open each RTP stream */
  2166.     for (i = 0; i < rt->nb_rtsp_streams; i++) {
  2167.         char namebuf[50];
  2168.         rtsp_st = rt->rtsp_streams[i];
  2169.  
  2170.         if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
  2171.             getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
  2172.                         namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
  2173.             ff_url_join(url, sizeof(url), "rtp", NULL,
  2174.                         namebuf, rtsp_st->sdp_port,
  2175.                         "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
  2176.                         rtsp_st->sdp_port, rtsp_st->sdp_ttl,
  2177.                         rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
  2178.                         rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
  2179.  
  2180.             append_source_addrs(url, sizeof(url), "sources",
  2181.                                 rtsp_st->nb_include_source_addrs,
  2182.                                 rtsp_st->include_source_addrs);
  2183.             append_source_addrs(url, sizeof(url), "block",
  2184.                                 rtsp_st->nb_exclude_source_addrs,
  2185.                                 rtsp_st->exclude_source_addrs);
  2186.             if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
  2187.                            &s->interrupt_callback, NULL) < 0) {
  2188.                 err = AVERROR_INVALIDDATA;
  2189.                 goto fail;
  2190.             }
  2191.         }
  2192.         if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
  2193.             goto fail;
  2194.     }
  2195.     return 0;
  2196. fail:
  2197.     ff_rtsp_close_streams(s);
  2198.     ff_network_close();
  2199.     return err;
  2200. }
  2201.  
  2202. static int sdp_read_close(AVFormatContext *s)
  2203. {
  2204.     ff_rtsp_close_streams(s);
  2205.     ff_network_close();
  2206.     return 0;
  2207. }
  2208.  
  2209. static const AVClass sdp_demuxer_class = {
  2210.     .class_name     = "SDP demuxer",
  2211.     .item_name      = av_default_item_name,
  2212.     .option         = sdp_options,
  2213.     .version        = LIBAVUTIL_VERSION_INT,
  2214. };
  2215.  
  2216. AVInputFormat ff_sdp_demuxer = {
  2217.     .name           = "sdp",
  2218.     .long_name      = NULL_IF_CONFIG_SMALL("SDP"),
  2219.     .priv_data_size = sizeof(RTSPState),
  2220.     .read_probe     = sdp_probe,
  2221.     .read_header    = sdp_read_header,
  2222.     .read_packet    = ff_rtsp_fetch_packet,
  2223.     .read_close     = sdp_read_close,
  2224.     .priv_class     = &sdp_demuxer_class,
  2225. };
  2226. #endif /* CONFIG_SDP_DEMUXER */
  2227.  
  2228. #if CONFIG_RTP_DEMUXER
  2229. static int rtp_probe(AVProbeData *p)
  2230. {
  2231.     if (av_strstart(p->filename, "rtp:", NULL))
  2232.         return AVPROBE_SCORE_MAX;
  2233.     return 0;
  2234. }
  2235.  
  2236. static int rtp_read_header(AVFormatContext *s)
  2237. {
  2238.     uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
  2239.     char host[500], sdp[500];
  2240.     int ret, port;
  2241.     URLContext* in = NULL;
  2242.     int payload_type;
  2243.     AVCodecContext codec = { 0 };
  2244.     struct sockaddr_storage addr;
  2245.     AVIOContext pb;
  2246.     socklen_t addrlen = sizeof(addr);
  2247.     RTSPState *rt = s->priv_data;
  2248.  
  2249.     if (!ff_network_init())
  2250.         return AVERROR(EIO);
  2251.  
  2252.     ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ,
  2253.                      &s->interrupt_callback, NULL);
  2254.     if (ret)
  2255.         goto fail;
  2256.  
  2257.     while (1) {
  2258.         ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
  2259.         if (ret == AVERROR(EAGAIN))
  2260.             continue;
  2261.         if (ret < 0)
  2262.             goto fail;
  2263.         if (ret < 12) {
  2264.             av_log(s, AV_LOG_WARNING, "Received too short packet\n");
  2265.             continue;
  2266.         }
  2267.  
  2268.         if ((recvbuf[0] & 0xc0) != 0x80) {
  2269.             av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
  2270.                                       "received\n");
  2271.             continue;
  2272.         }
  2273.  
  2274.         if (RTP_PT_IS_RTCP(recvbuf[1]))
  2275.             continue;
  2276.  
  2277.         payload_type = recvbuf[1] & 0x7f;
  2278.         break;
  2279.     }
  2280.     getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
  2281.     ffurl_close(in);
  2282.     in = NULL;
  2283.  
  2284.     if (ff_rtp_get_codec_info(&codec, payload_type)) {
  2285.         av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
  2286.                                 "without an SDP file describing it\n",
  2287.                                  payload_type);
  2288.         goto fail;
  2289.     }
  2290.     if (codec.codec_type != AVMEDIA_TYPE_DATA) {
  2291.         av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
  2292.                                   "properly you need an SDP file "
  2293.                                   "describing it\n");
  2294.     }
  2295.  
  2296.     av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
  2297.                  NULL, 0, s->filename);
  2298.  
  2299.     snprintf(sdp, sizeof(sdp),
  2300.              "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
  2301.              addr.ss_family == AF_INET ? 4 : 6, host,
  2302.              codec.codec_type == AVMEDIA_TYPE_DATA  ? "application" :
  2303.              codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
  2304.              port, payload_type);
  2305.     av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
  2306.  
  2307.     ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);
  2308.     s->pb = &pb;
  2309.  
  2310.     /* sdp_read_header initializes this again */
  2311.     ff_network_close();
  2312.  
  2313.     rt->media_type_mask = (1 << (AVMEDIA_TYPE_DATA+1)) - 1;
  2314.  
  2315.     ret = sdp_read_header(s);
  2316.     s->pb = NULL;
  2317.     return ret;
  2318.  
  2319. fail:
  2320.     if (in)
  2321.         ffurl_close(in);
  2322.     ff_network_close();
  2323.     return ret;
  2324. }
  2325.  
  2326. static const AVClass rtp_demuxer_class = {
  2327.     .class_name     = "RTP demuxer",
  2328.     .item_name      = av_default_item_name,
  2329.     .option         = rtp_options,
  2330.     .version        = LIBAVUTIL_VERSION_INT,
  2331. };
  2332.  
  2333. AVInputFormat ff_rtp_demuxer = {
  2334.     .name           = "rtp",
  2335.     .long_name      = NULL_IF_CONFIG_SMALL("RTP input"),
  2336.     .priv_data_size = sizeof(RTSPState),
  2337.     .read_probe     = rtp_probe,
  2338.     .read_header    = rtp_read_header,
  2339.     .read_packet    = ff_rtsp_fetch_packet,
  2340.     .read_close     = sdp_read_close,
  2341.     .flags          = AVFMT_NOFILE,
  2342.     .priv_class     = &rtp_demuxer_class,
  2343. };
  2344. #endif /* CONFIG_RTP_DEMUXER */
  2345.