libavformat.hg: rtsp.c comparison

comparison rtsp.c @ 774:820863425158 libavformat

RTP/RTSP and MPEG4-AAC audio - preliminary support for mpeg4-aac rtp payload (no interleaving support) - use udp transport as default (makes more sense with rtp, doesn't it ?) - some code factorization, so adding support for new rtp payload will be easier (I hope ;-) patch by (Romain DEGEZ: romain degez, smartjog com)

author	michael
date	Thu, 26 May 2005 07:47:51 +0000
parents	fc254f396f15
children	feca73904e67

comparison

equal deleted inserted replaced

-:a5095f5cf38a
+:820863425158
 int sdp_port; /* port (from SDP content - not used in RTSP) */
 struct in_addr sdp_ip; /* IP address  (from SDP content - not used in RTSP) */
 int sdp_ttl;  /* IP TTL (from SDP content - not used in RTSP) */
 int sdp_payload_type; /* payload type - only used in SDP */
+rtp_payload_data_t rtp_payload_data; /* rtp payload parsing infos from SDP */
 } RTSPStream;
 static int rtsp_read_play(AVFormatContext *s);
 /* XXX: currently, the only way to change the protocols consists in
 changing this variable */
-#if 0
-int rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_TCP) | (1 << RTSP_PROTOCOL_RTP_UDP) | (1 << RTSP_PROTOCOL_RTP_UDP_MULTICAST);
+int rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_UDP);
-#else
-/* try it if a proxy is used */
-int rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_TCP);
-#endif
-/* if non zero, then set a range for RTP ports */
-int rtsp_rtp_port_min = 0;
-int rtsp_rtp_port_max = 0;
 FFRTSPCallback *ff_rtsp_callback = NULL;
 static int rtsp_probe(AVProbeData *p)
 {
 {
 const char *p;
 char *q;
 p = *pp;
+if (*p == '/')
+p++;
 skip_spaces(&p);
 q = buf;
 while (!strchr(sep, *p) && *p != '\0') {
 if ((q - buf) < buf_size - 1)
 *q++ = *p;
 *pp = p;
 }
 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other
 params>] */
-static int sdp_parse_rtpmap(AVCodecContext *codec, const char *p)
+static int sdp_parse_rtpmap(AVCodecContext *codec, int payload_type, const char *p)
 {
 char buf[256];
+int i;
-/* codec name */
+AVCodec *c;
+char *c_name;
+/* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
+see if we can handle this kind of payload */
 get_word_sep(buf, sizeof(buf), "/", &p);
-if (!strcmp(buf, "MP4V-ES")) {
+if (payload_type >= RTP_PT_PRIVATE) {
-codec->codec_id = CODEC_ID_MPEG4;
+/* We are in dynmaic payload type case ... search into AVRtpDynamicPayloadTypes[] */
+for (i = 0; AVRtpDynamicPayloadTypes[i].codec_id != CODEC_ID_NONE; ++i)
+if (!strcmp(buf, AVRtpDynamicPayloadTypes[i].enc_name) && (codec->codec_type == AVRtpDynamicPayloadTypes[i].codec_type)) {
+codec->codec_id = AVRtpDynamicPayloadTypes[i].codec_id;
+break;
+}
+} else {
+/* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
+/* search into AVRtpPayloadTypes[] */
+for (i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
+if (!strcmp(buf, AVRtpPayloadTypes[i].enc_name) && (codec->codec_type == AVRtpPayloadTypes[i].codec_type)){
+codec->codec_id = AVRtpPayloadTypes[i].codec_id;
+break;
+}
+}
+c = avcodec_find_decoder(codec->codec_id);
+if (c && c->name)
+c_name = (char *)c->name;
+else
+c_name = (char *)NULL;
+if (c_name) {
+get_word_sep(buf, sizeof(buf), "/", &p);
+i = atoi(buf);
+switch (codec->codec_type) {
+case CODEC_TYPE_AUDIO:
+av_log(codec, AV_LOG_DEBUG, " audio codec set to : %s\n", c_name);
+codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
+codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
+if (i > 0) {
+codec->sample_rate = i;
+get_word_sep(buf, sizeof(buf), "/", &p);
+i = atoi(buf);
+if (i > 0)
+codec->channels = i;
+}
+av_log(codec, AV_LOG_DEBUG, " audio samplerate set to : %i\n", codec->sample_rate);
+av_log(codec, AV_LOG_DEBUG, " audio channels set to : %i\n", codec->channels);
+break;
+case CODEC_TYPE_VIDEO:
+av_log(codec, AV_LOG_DEBUG, " video codec set to : %s\n", c_name);
+break;
+default:
+break;
+}
 return 0;
-} else {
+}
-return -1;
-}
+return -1;
 }
 /* return the length and optionnaly the data */
 static int hex_to_data(uint8_t *data, const char *p)
 {
 }
 }
 return len;
 }
-static void sdp_parse_fmtp(AVCodecContext *codec, const char *p)
+static void sdp_parse_fmtp_config(AVCodecContext *codec, char *attr, char *value)
+{
+switch (codec->codec_id) {
+case CODEC_ID_MPEG4:
+case CODEC_ID_MPEG4AAC:
+if (!strcmp(attr, "config")) {
+/* decode the hexa encoded parameter */
+int len = hex_to_data(NULL, value);
+codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
+if (!codec->extradata)
+return;
+codec->extradata_size = len;
+hex_to_data(codec->extradata, value);
+}
+break;
+default:
+break;
+}
+return;
+}
+typedef struct attrname_map
+{
+char *str;
+uint16_t type;
+uint32_t offset;
+} attrname_map_t;
+/* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
+#define ATTR_NAME_TYPE_INT 0
+#define ATTR_NAME_TYPE_STR 1
+static attrname_map_t attr_names[]=
+{
+{"SizeLength",       ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, sizelength)},
+{"IndexLength",      ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, indexlength)},
+{"IndexDeltaLength", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, indexdeltalength)},
+{"profile-level-id", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, profile_level_id)},
+{"StreamType",       ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, streamtype)},
+{"mode",             ATTR_NAME_TYPE_STR, offsetof(rtp_payload_data_t, mode)},
+{NULL, -1, -1},
+};
+/* parse a SDP line and save stream attributes */
+static void sdp_parse_fmtp(AVStream *st, const char *p)
 {
 char attr[256];
 char value[4096];
-int len;
+int i;
+RTSPStream *rtsp_st = st->priv_data;
+AVCodecContext *codec = &st->codec;
+rtp_payload_data_t *rtp_payload_data = &rtsp_st->rtp_payload_data;
 /* loop on each attribute */
 for(;;) {
 skip_spaces(&p);
 if (*p == '\0')
 if (*p == '=')
 p++;
 get_word_sep(value, sizeof(value), ";", &p);
 if (*p == ';')
 p++;
-/* handle MPEG4 video */
+	/* grab the codec extra_data from the config parameter of the fmtp line */
-switch(codec->codec_id) {
+sdp_parse_fmtp_config(codec, attr, value);
-case CODEC_ID_MPEG4:
+/* Looking for a known attribute */
-if (!strcmp(attr, "config")) {
+for (i = 0; attr_names[i].str; ++i) {
-/* decode the hexa encoded parameter */
+if (!strcasecmp(attr, attr_names[i].str)) {
-len = hex_to_data(NULL, value);
+if (attr_names[i].type == ATTR_NAME_TYPE_INT)
-codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
+*(int *)((char *)rtp_payload_data + attr_names[i].offset) = atoi(value);
-if (!codec->extradata)
+else if (attr_names[i].type == ATTR_NAME_TYPE_STR)
-goto fail;
+*(char **)((char *)rtp_payload_data + attr_names[i].offset) = av_strdup(value);
-codec->extradata_size = len;
+	    }
-hex_to_data(codec->extradata, value);
+}
-}
-break;
-default:
-/* ignore data for other codecs */
-break;
-}
-fail: ;
-//        printf("'%s' = '%s'\n", attr, value);
 }
 }
 typedef struct SDPParseState {
 /* SDP only */
 /* XXX: handle list of formats */
 get_word(buf1, sizeof(buf1), &p); /* format list */
 rtsp_st->sdp_payload_type = atoi(buf1);
-if (rtsp_st->sdp_payload_type == RTP_PT_MPEG2TS) {
+if (!strcmp(AVRtpPayloadTypes[rtsp_st->sdp_payload_type].enc_name, "MP2T")) {
 /* no corresponding stream */
 } else {
 st = av_new_stream(s, 0);
 if (!st)
 return;
 st->priv_data = rtsp_st;
 rtsp_st->stream_index = st->index;
 st->codec.codec_type = codec_type;
-if (rtsp_st->sdp_payload_type < 96) {
+if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
 /* if standard payload type, we can find the codec right now */
 rtp_get_codec_info(&st->codec, rtsp_st->sdp_payload_type);
 }
 }
 /* put a default control url */
 payload_type = atoi(buf1);
 for(i = 0; i < s->nb_streams;i++) {
 st = s->streams[i];
 rtsp_st = st->priv_data;
 if (rtsp_st->sdp_payload_type == payload_type) {
-sdp_parse_rtpmap(&st->codec, p);
+sdp_parse_rtpmap(&st->codec, payload_type, p);
 }
 }
 } else if (strstart(p, "fmtp:", &p)) {
 /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
 get_word(buf1, sizeof(buf1), &p);
 payload_type = atoi(buf1);
 for(i = 0; i < s->nb_streams;i++) {
 st = s->streams[i];
 rtsp_st = st->priv_data;
 if (rtsp_st->sdp_payload_type == payload_type) {
-sdp_parse_fmtp(&st->codec, p);
+sdp_parse_fmtp(st, p);
 }
 }
 }
 break;
 }
 AVFormatParameters *ap)
 {
 RTSPState *rt = s->priv_data;
 char host[1024], path[1024], tcpname[1024], cmd[2048];
 URLContext *rtsp_hd;
-int port, i, ret, err;
+int port, i, j, ret, err;
 RTSPHeader reply1, *reply = &reply1;
 unsigned char *content = NULL;
 RTSPStream *rtsp_st;
 int protocol_mask;
 AVStream *st;
 protocol_mask = rtsp_default_protocols;
 /* for each stream, make the setup request */
 /* XXX: we assume the same server is used for the control of each
 RTSP stream */
-for(i=0;i<rt->nb_rtsp_streams;i++) {
+for(j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) {
 char transport[2048];
 rtsp_st = rt->rtsp_streams[i];
 /* compute available transports */
 transport[0] = '\0';
 /* RTP/UDP */
 if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP)) {
 char buf[256];
-int j;
 /* first try in specified port range */
-if (rtsp_rtp_port_min != 0) {
+if (RTSP_RTP_PORT_MIN != 0) {
-for(j=rtsp_rtp_port_min;j<=rtsp_rtp_port_max;j++) {
+while(j <= RTSP_RTP_PORT_MAX) {
 snprintf(buf, sizeof(buf), "rtp://?localport=%d", j);
-if (url_open(&rtsp_st->rtp_handle, buf, URL_RDONLY) == 0)
+if (url_open(&rtsp_st->rtp_handle, buf, URL_RDONLY) == 0) {
+j += 2; /* we will use two port by rtp stream (rtp and rtcp) */
 goto rtp_opened;
+}
 }
 }
-/* then try on any port */
+/*            then try on any port
-if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
+**            if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
-err = AVERROR_INVALIDDATA;
+**                err = AVERROR_INVALIDDATA;
-goto fail;
+**                goto fail;
-}
+**            }
+*/
 rtp_opened:
 port = rtp_get_local_port(rtsp_st->rtp_handle);
 if (transport[0] != '\0')
 pstrcat(transport, sizeof(transport), ",");
 "RTP/AVP/UDP;unicast;client_port=%d-%d",
 port, port + 1);
 }
 /* RTP/TCP */
-if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_TCP)) {
+else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_TCP)) {
 if (transport[0] != '\0')
 pstrcat(transport, sizeof(transport), ",");
 snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1,
 "RTP/AVP/TCP");
 }
-if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP_MULTICAST)) {
+else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP_MULTICAST)) {
 if (transport[0] != '\0')
 pstrcat(transport, sizeof(transport), ",");
 snprintf(transport + strlen(transport),
 sizeof(transport) - strlen(transport) - 1,
 "RTP/AVP/UDP;multicast");
 st = NULL;
 if (rtsp_st->stream_index >= 0)
 st = s->streams[rtsp_st->stream_index];
 if (!st)
 s->ctx_flags |= AVFMTCTX_NOHEADER;
-rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->sdp_payload_type);
+rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data);
 if (!rtsp_st->rtp_ctx) {
 err = AVERROR_NOMEM;
 goto fail;
 }
 }
 st = NULL;
 if (rtsp_st->stream_index >= 0)
 st = s->streams[rtsp_st->stream_index];
 if (!st)
 s->ctx_flags |= AVFMTCTX_NOHEADER;
-rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->sdp_payload_type);
+rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data);
 if (!rtsp_st->rtp_ctx) {
 err = AVERROR_NOMEM;
 goto fail;
 }
 }

Mercurial > libavformat.hg

comparison rtsp.c @ 774:820863425158 libavformat