FFmpeg: libavformat/rtsp.c Source File

FFmpeg

[フレーム]

libavformat

rtsp.c

Go to the documentation of this file.

1 /*

2 * RTSP/SDP client

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 */

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"

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"

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"

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

62 #define OFFSET(x) offsetof(RTSPState, x)

63 #define DEC AV_OPT_FLAG_DECODING_PARAM

64 #define ENC AV_OPT_FLAG_ENCODING_PARAM

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" }

70 #define RTSP_MEDIATYPE_OPTS(name, longname) \

71 { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_SUBTITLE+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 { "subtitle", "Subtitle", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_SUBTITLE}, 0, 0, DEC, "allowed_media_types" }

77 #define RTSP_REORDERING_OPTS() \

78 { "reorder_queue_size", "set number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }

80 const AVOption ff_rtsp_options[] = {

81 { "initial_pause", "do not start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC },

82 FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),

83 { "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, "rtsp_transport" }, \

84 { "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \

85 { "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, "rtsp_transport" }, \

86 { "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, "rtsp_transport" },

87 { "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, "rtsp_transport" },

88 RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),

89 { "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, "rtsp_flags" },

90 { "prefer_tcp", "try RTP via TCP first, if available", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_PREFER_TCP}, 0, 0, DEC|ENC, "rtsp_flags" },

91 RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),

92 { "min_port", "set minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },

93 { "max_port", "set maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },

94 { "timeout", "set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen)", OFFSET(initial_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC },

95 { "stimeout", "set timeout (in microseconds) of socket TCP I/O operations", OFFSET(stimeout), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC },

96 RTSP_REORDERING_OPTS(),

97 { "user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },

98 { NULL },

99 };

100

101 static const AVOption sdp_options[] = {

102 RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),

103 { "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, "rtsp_flags" },

104 { "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" },

105 RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),

106 RTSP_REORDERING_OPTS(),

107 { NULL },

108 };

109

110 static const AVOption rtp_options[] = {

111 RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),

112 RTSP_REORDERING_OPTS(),

113 { NULL },

114 };

115

116 static void get_word_until_chars(char *buf, int buf_size,

117 const char *sep, const char **pp)

118 {

119 const char *p;

120 char *q;

121

122 p = *pp;

123 p += strspn(p, SPACE_CHARS);

124 q = buf;

125 while (!strchr(sep, *p) && *p != '0円') {

126 if ((q - buf) < buf_size - 1)

127 *q++ = *p;

128 p++;

129 }

130 if (buf_size > 0)

131 *q = '0円';

132 *pp = p;

133 }

134

135 static void get_word_sep(char *buf, int buf_size, const char *sep,

136 const char **pp)

137 {

138 if (**pp == '/') (*pp)++;

139 get_word_until_chars(buf, buf_size, sep, pp);

140 }

141

142 static void get_word(char *buf, int buf_size, const char **pp)

143 {

144 get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);

145 }

146

147 /** Parse a string p in the form of Range:npt=xx-xx, and determine the start

148 * and end time.

149 * Used for seeking in the rtp stream.

150 */

151 static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)

152 {

153 char buf[256];

154

155 p += strspn(p, SPACE_CHARS);

156 if (!av_stristart(p, "npt=", &p))

157 return;

158

159 *start = AV_NOPTS_VALUE;

160 *end = AV_NOPTS_VALUE;

161

162 get_word_sep(buf, sizeof(buf), "-", &p);

163 av_parse_time(start, buf, 1);

164 if (*p == '-') {

165 p++;

166 get_word_sep(buf, sizeof(buf), "-", &p);

167 av_parse_time(end, buf, 1);

168 }

169 }

170

171 static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)

172 {

173 struct addrinfo hints = { 0 }, *ai = NULL;

174 hints.ai_flags = AI_NUMERICHOST;

175 if (getaddrinfo(buf, NULL, &hints, &ai))

176 return -1;

177 memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));

178 freeaddrinfo(ai);

179 return 0;

180 }

181

182 #if CONFIG_RTPDEC

183 static void init_rtp_handler(RTPDynamicProtocolHandler *handler,

184 RTSPStream *rtsp_st, AVStream *st)

185 {

186 AVCodecContext *codec = st ? st->codec : NULL;

187 if (!handler)

188 return;

189 if (codec)

190 codec->codec_id = handler->codec_id;

191 rtsp_st->dynamic_handler = handler;

192 if (st)

193 st->need_parsing = handler->need_parsing;

194 if (handler->priv_data_size) {

195 rtsp_st->dynamic_protocol_context = av_mallocz(handler->priv_data_size);

196 if (!rtsp_st->dynamic_protocol_context)

197 rtsp_st->dynamic_handler = NULL;

198 }

199 }

200

201 static void finalize_rtp_handler_init(AVFormatContext *s, RTSPStream *rtsp_st,

202 AVStream *st)

203 {

204 if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init) {

205 int ret = rtsp_st->dynamic_handler->init(s, st ? st->index : -1,

206 rtsp_st->dynamic_protocol_context);

207 if (ret < 0) {

208 if (rtsp_st->dynamic_protocol_context) {

209 if (rtsp_st->dynamic_handler->close)

210 rtsp_st->dynamic_handler->close(

211 rtsp_st->dynamic_protocol_context);

212 av_free(rtsp_st->dynamic_protocol_context);

213 }

214 rtsp_st->dynamic_protocol_context = NULL;

215 rtsp_st->dynamic_handler = NULL;

216 }

217 }

218 }

219

220 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */

221 static int sdp_parse_rtpmap(AVFormatContext *s,

222 AVStream *st, RTSPStream *rtsp_st,

223 int payload_type, const char *p)

224 {

225 AVCodecContext *codec = st->codec;

226 char buf[256];

227 int i;

228 AVCodec *c;

229 const char *c_name;

230

231 /* See if we can handle this kind of payload.

232 * The space should normally not be there but some Real streams or

233 * particular servers ("RealServer Version 6.1.3.970", see issue 1658)

234 * have a trailing space. */

235 get_word_sep(buf, sizeof(buf), "/ ", &p);

236 if (payload_type < RTP_PT_PRIVATE) {

237 /* We are in a standard case

238 * (from http://www.iana.org/assignments/rtp-parameters). */

239 codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);

240 }

241

242 if (codec->codec_id == AV_CODEC_ID_NONE) {

243 RTPDynamicProtocolHandler *handler =

244 ff_rtp_handler_find_by_name(buf, codec->codec_type);

245 init_rtp_handler(handler, rtsp_st, st);

246 /* If no dynamic handler was found, check with the list of standard

247 * allocated types, if such a stream for some reason happens to

248 * use a private payload type. This isn't handled in rtpdec.c, since

249 * the format name from the rtpmap line never is passed into rtpdec. */

250 if (!rtsp_st->dynamic_handler)

251 codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);

252 }

253

254 c = avcodec_find_decoder(codec->codec_id);

255 if (c && c->name)

256 c_name = c->name;

257 else

258 c_name = "(null)";

259

260 get_word_sep(buf, sizeof(buf), "/", &p);

261 i = atoi(buf);

262 switch (codec->codec_type) {

263 case AVMEDIA_TYPE_AUDIO:

264 av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);

265 codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;

266 codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;

267 if (i > 0) {

268 codec->sample_rate = i;

269 avpriv_set_pts_info(st, 32, 1, codec->sample_rate);

270 get_word_sep(buf, sizeof(buf), "/", &p);

271 i = atoi(buf);

272 if (i > 0)

273 codec->channels = i;

274 }

275 av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",

276 codec->sample_rate);

277 av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",

278 codec->channels);

279 break;

280 case AVMEDIA_TYPE_VIDEO:

281 av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);

282 if (i > 0)

283 avpriv_set_pts_info(st, 32, 1, i);

284 break;

285 default:

286 break;

287 }

288 finalize_rtp_handler_init(s, rtsp_st, st);

289 return 0;

290 }

291

292 /* parse the attribute line from the fmtp a line of an sdp response. This

293 * is broken out as a function because it is used in rtp_h264.c, which is

294 * forthcoming. */

295 int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,

296 char *value, int value_size)

297 {

298 *p += strspn(*p, SPACE_CHARS);

299 if (**p) {

300 get_word_sep(attr, attr_size, "=", p);

301 if (**p == '=')

302 (*p)++;

303 get_word_sep(value, value_size, ";", p);

304 if (**p == ';')

305 (*p)++;

306 return 1;

307 }

308 return 0;

309 }

310

311 typedef struct SDPParseState {

312 /* SDP only */

313 struct sockaddr_storage default_ip;

314 int default_ttl;

315 int skip_media; ///< set if an unknown m= line occurs

316 int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */

317 struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */

318 int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */

319 struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */

320 int seen_rtpmap;

321 int seen_fmtp;

322 char delayed_fmtp[2048];

323 } SDPParseState;

324

325 static void copy_default_source_addrs(struct RTSPSource **addrs, int count,

326 struct RTSPSource ***dest, int *dest_count)

327 {

328 RTSPSource *rtsp_src, *rtsp_src2;

329 int i;

330 for (i = 0; i < count; i++) {

331 rtsp_src = addrs[i];

332 rtsp_src2 = av_malloc(sizeof(*rtsp_src2));

333 if (!rtsp_src2)

334 continue;

335 memcpy(rtsp_src2, rtsp_src, sizeof(*rtsp_src));

336 dynarray_add(dest, dest_count, rtsp_src2);

337 }

338 }

339

340 static void parse_fmtp(AVFormatContext *s, RTSPState *rt,

341 int payload_type, const char *line)

342 {

343 int i;

344

345 for (i = 0; i < rt->nb_rtsp_streams; i++) {

346 RTSPStream *rtsp_st = rt->rtsp_streams[i];

347 if (rtsp_st->sdp_payload_type == payload_type &&

348 rtsp_st->dynamic_handler &&

349 rtsp_st->dynamic_handler->parse_sdp_a_line) {

350 rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,

351 rtsp_st->dynamic_protocol_context, line);

352 }

353 }

354 }

355

356 static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,

357 int letter, const char *buf)

358 {

359 RTSPState *rt = s->priv_data;

360 char buf1[64], st_type[64];

361 const char *p;

362 enum AVMediaType codec_type;

363 int payload_type;

364 AVStream *st;

365 RTSPStream *rtsp_st;

366 RTSPSource *rtsp_src;

367 struct sockaddr_storage sdp_ip;

368 int ttl;

369

370 av_dlog(s, "sdp: %c='%s'\n", letter, buf);

371

372 p = buf;

373 if (s1->skip_media && letter != 'm')

374 return;

375 switch (letter) {

376 case 'c':

377 get_word(buf1, sizeof(buf1), &p);

378 if (strcmp(buf1, "IN") != 0)

379 return;

380 get_word(buf1, sizeof(buf1), &p);

381 if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))

382 return;

383 get_word_sep(buf1, sizeof(buf1), "/", &p);

384 if (get_sockaddr(buf1, &sdp_ip))

385 return;

386 ttl = 16;

387 if (*p == '/') {

388 p++;

389 get_word_sep(buf1, sizeof(buf1), "/", &p);

390 ttl = atoi(buf1);

391 }

392 if (s->nb_streams == 0) {

393 s1->default_ip = sdp_ip;

394 s1->default_ttl = ttl;

395 } else {

396 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

397 rtsp_st->sdp_ip = sdp_ip;

398 rtsp_st->sdp_ttl = ttl;

399 }

400 break;

401 case 's':

402 av_dict_set(&s->metadata, "title", p, 0);

403 break;

404 case 'i':

405 if (s->nb_streams == 0) {

406 av_dict_set(&s->metadata, "comment", p, 0);

407 break;

408 }

409 break;

410 case 'm':

411 /* new stream */

412 s1->skip_media = 0;

413 s1->seen_fmtp = 0;

414 s1->seen_rtpmap = 0;

415 codec_type = AVMEDIA_TYPE_UNKNOWN;

416 get_word(st_type, sizeof(st_type), &p);

417 if (!strcmp(st_type, "audio")) {

418 codec_type = AVMEDIA_TYPE_AUDIO;

419 } else if (!strcmp(st_type, "video")) {

420 codec_type = AVMEDIA_TYPE_VIDEO;

421 } else if (!strcmp(st_type, "application")) {

422 codec_type = AVMEDIA_TYPE_DATA;

423 } else if (!strcmp(st_type, "text")) {

424 codec_type = AVMEDIA_TYPE_SUBTITLE;

425 }

426 if (codec_type == AVMEDIA_TYPE_UNKNOWN || !(rt->media_type_mask & (1 << codec_type))) {

427 s1->skip_media = 1;

428 return;

429 }

430 rtsp_st = av_mallocz(sizeof(RTSPStream));

431 if (!rtsp_st)

432 return;

433 rtsp_st->stream_index = -1;

434 dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);

435

436 rtsp_st->sdp_ip = s1->default_ip;

437 rtsp_st->sdp_ttl = s1->default_ttl;

438

439 copy_default_source_addrs(s1->default_include_source_addrs,

440 s1->nb_default_include_source_addrs,

441 &rtsp_st->include_source_addrs,

442 &rtsp_st->nb_include_source_addrs);

443 copy_default_source_addrs(s1->default_exclude_source_addrs,

444 s1->nb_default_exclude_source_addrs,

445 &rtsp_st->exclude_source_addrs,

446 &rtsp_st->nb_exclude_source_addrs);

447

448 get_word(buf1, sizeof(buf1), &p); /* port */

449 rtsp_st->sdp_port = atoi(buf1);

450

451 get_word(buf1, sizeof(buf1), &p); /* protocol */

452 if (!strcmp(buf1, "udp"))

453 rt->transport = RTSP_TRANSPORT_RAW;

454 else if (strstr(buf1, "/AVPF") || strstr(buf1, "/SAVPF"))

455 rtsp_st->feedback = 1;

456

457 /* XXX: handle list of formats */

458 get_word(buf1, sizeof(buf1), &p); /* format list */

459 rtsp_st->sdp_payload_type = atoi(buf1);

460

461 if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {

462 /* no corresponding stream */

463 if (rt->transport == RTSP_TRANSPORT_RAW) {

464 if (CONFIG_RTPDEC && !rt->ts)

465 rt->ts = avpriv_mpegts_parse_open(s);

466 } else {

467 RTPDynamicProtocolHandler *handler;

468 handler = ff_rtp_handler_find_by_id(

469 rtsp_st->sdp_payload_type, AVMEDIA_TYPE_DATA);

470 init_rtp_handler(handler, rtsp_st, NULL);

471 finalize_rtp_handler_init(s, rtsp_st, NULL);

472 }

473 } else if (rt->server_type == RTSP_SERVER_WMS &&

474 codec_type == AVMEDIA_TYPE_DATA) {

475 /* RTX stream, a stream that carries all the other actual

476 * audio/video streams. Don't expose this to the callers. */

477 } else {

478 st = avformat_new_stream(s, NULL);

479 if (!st)

480 return;

481 st->id = rt->nb_rtsp_streams - 1;

482 rtsp_st->stream_index = st->index;

483 st->codec->codec_type = codec_type;

484 if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {

485 RTPDynamicProtocolHandler *handler;

486 /* if standard payload type, we can find the codec right now */

487 ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);

488 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&

489 st->codec->sample_rate > 0)

490 avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);

491 /* Even static payload types may need a custom depacketizer */

492 handler = ff_rtp_handler_find_by_id(

493 rtsp_st->sdp_payload_type, st->codec->codec_type);

494 init_rtp_handler(handler, rtsp_st, st);

495 finalize_rtp_handler_init(s, rtsp_st, st);

496 }

497 if (rt->default_lang[0])

498 av_dict_set(&st->metadata, "language", rt->default_lang, 0);

499 }

500 /* put a default control url */

501 av_strlcpy(rtsp_st->control_url, rt->control_uri,

502 sizeof(rtsp_st->control_url));

503 break;

504 case 'a':

505 if (av_strstart(p, "control:", &p)) {

506 if (s->nb_streams == 0) {

507 if (!strncmp(p, "rtsp://", 7))

508 av_strlcpy(rt->control_uri, p,

509 sizeof(rt->control_uri));

510 } else {

511 char proto[32];

512 /* get the control url */

513 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

514

515 /* XXX: may need to add full url resolution */

516 av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,

517 NULL, NULL, 0, p);

518 if (proto[0] == '0円') {

519 /* relative control URL */

520 if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')

521 av_strlcat(rtsp_st->control_url, "/",

522 sizeof(rtsp_st->control_url));

523 av_strlcat(rtsp_st->control_url, p,

524 sizeof(rtsp_st->control_url));

525 } else

526 av_strlcpy(rtsp_st->control_url, p,

527 sizeof(rtsp_st->control_url));

528 }

529 } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {

530 /* NOTE: rtpmap is only supported AFTER the 'm=' tag */

531 get_word(buf1, sizeof(buf1), &p);

532 payload_type = atoi(buf1);

533 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

534 if (rtsp_st->stream_index >= 0) {

535 st = s->streams[rtsp_st->stream_index];

536 sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);

537 }

538 s1->seen_rtpmap = 1;

539 if (s1->seen_fmtp) {

540 parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);

541 }

542 } else if (av_strstart(p, "fmtp:", &p) ||

543 av_strstart(p, "framesize:", &p)) {

544 // let dynamic protocol handlers have a stab at the line.

545 get_word(buf1, sizeof(buf1), &p);

546 payload_type = atoi(buf1);

547 if (s1->seen_rtpmap) {

548 parse_fmtp(s, rt, payload_type, buf);

549 } else {

550 s1->seen_fmtp = 1;

551 av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp));

552 }

553 } else if (av_strstart(p, "range:", &p)) {

554 int64_t start, end;

555

556 // this is so that seeking on a streamed file can work.

557 rtsp_parse_range_npt(p, &start, &end);

558 s->start_time = start;

559 /* AV_NOPTS_VALUE means live broadcast (and can't seek) */

560 s->duration = (end == AV_NOPTS_VALUE) ?

561 AV_NOPTS_VALUE : end - start;

562 } else if (av_strstart(p, "lang:", &p)) {

563 if (s->nb_streams > 0) {

564 get_word(buf1, sizeof(buf1), &p);

565 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

566 if (rtsp_st->stream_index >= 0) {

567 st = s->streams[rtsp_st->stream_index];

568 av_dict_set(&st->metadata, "language", buf1, 0);

569 }

570 } else

571 get_word(rt->default_lang, sizeof(rt->default_lang), &p);

572 } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {

573 if (atoi(p) == 1)

574 rt->transport = RTSP_TRANSPORT_RDT;

575 } else if (av_strstart(p, "SampleRate:integer;", &p) &&

576 s->nb_streams > 0) {

577 st = s->streams[s->nb_streams - 1];

578 st->codec->sample_rate = atoi(p);

579 } else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {

580 // RFC 4568

581 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

582 get_word(buf1, sizeof(buf1), &p); // ignore tag

583 get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);

584 p += strspn(p, SPACE_CHARS);

585 if (av_strstart(p, "inline:", &p))

586 get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);

587 } else if (av_strstart(p, "source-filter:", &p)) {

588 int exclude = 0;

589 get_word(buf1, sizeof(buf1), &p);

590 if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))

591 return;

592 exclude = !strcmp(buf1, "excl");

593

594 get_word(buf1, sizeof(buf1), &p);

595 if (strcmp(buf1, "IN") != 0)

596 return;

597 get_word(buf1, sizeof(buf1), &p);

598 if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))

599 return;

600 // not checking that the destination address actually matches or is wildcard

601 get_word(buf1, sizeof(buf1), &p);

602

603 while (*p != '0円') {

604 rtsp_src = av_mallocz(sizeof(*rtsp_src));

605 if (!rtsp_src)

606 return;

607 get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);

608 if (exclude) {

609 if (s->nb_streams == 0) {

610 dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);

611 } else {

612 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

613 dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);

614 }

615 } else {

616 if (s->nb_streams == 0) {

617 dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);

618 } else {

619 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

620 dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);

621 }

622 }

623 }

624 } else {

625 if (rt->server_type == RTSP_SERVER_WMS)

626 ff_wms_parse_sdp_a_line(s, p);

627 if (s->nb_streams > 0) {

628 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];

629

630 if (rt->server_type == RTSP_SERVER_REAL)

631 ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p);

632

633 if (rtsp_st->dynamic_handler &&

634 rtsp_st->dynamic_handler->parse_sdp_a_line)

635 rtsp_st->dynamic_handler->parse_sdp_a_line(s,

636 rtsp_st->stream_index,

637 rtsp_st->dynamic_protocol_context, buf);

638 }

639 }

640 break;

641 }

642 }

643

644 int ff_sdp_parse(AVFormatContext *s, const char *content)

645 {

646 RTSPState *rt = s->priv_data;

647 const char *p;

648 int letter, i;

649 /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,

650 * contain long SDP lines containing complete ASF Headers (several

651 * kB) or arrays of MDPR (RM stream descriptor) headers plus

652 * "rulebooks" describing their properties. Therefore, the SDP line

653 * buffer is large.

654 *

655 * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line

656 * in rtpdec_xiph.c. */

657 char buf[16384], *q;

658 SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;

659

660 p = content;

661 for (;;) {

662 p += strspn(p, SPACE_CHARS);

663 letter = *p;

664 if (letter == '0円')

665 break;

666 p++;

667 if (*p != '=')

668 goto next_line;

669 p++;

670 /* get the content */

671 q = buf;

672 while (*p != '\n' && *p != '\r' && *p != '0円') {

673 if ((q - buf) < sizeof(buf) - 1)

674 *q++ = *p;

675 p++;

676 }

677 *q = '0円';

678 sdp_parse_line(s, s1, letter, buf);

679 next_line:

680 while (*p != '\n' && *p != '0円')

681 p++;

682 if (*p == '\n')

683 p++;

684 }

685

686 for (i = 0; i < s1->nb_default_include_source_addrs; i++)

687 av_freep(&s1->default_include_source_addrs[i]);

688 av_freep(&s1->default_include_source_addrs);

689 for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)

690 av_freep(&s1->default_exclude_source_addrs[i]);

691 av_freep(&s1->default_exclude_source_addrs);

692

693 rt->p = av_malloc_array(rt->nb_rtsp_streams + 1, sizeof(struct pollfd) * 2);

694 if (!rt->p) return AVERROR(ENOMEM);

695 return 0;

696 }

697 #endif /* CONFIG_RTPDEC */

698

699 void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)

700 {

701 RTSPState *rt = s->priv_data;

702 int i;

703

704 for (i = 0; i < rt->nb_rtsp_streams; i++) {

705 RTSPStream *rtsp_st = rt->rtsp_streams[i];

706 if (!rtsp_st)

707 continue;

708 if (rtsp_st->transport_priv) {

709 if (s->oformat) {

710 AVFormatContext *rtpctx = rtsp_st->transport_priv;

711 av_write_trailer(rtpctx);

712 if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {

713 if (CONFIG_RTSP_MUXER && rtpctx->pb && send_packets)

714 ff_rtsp_tcp_write_packet(s, rtsp_st);

715 ffio_free_dyn_buf(&rtpctx->pb);

716 } else {

717 avio_closep(&rtpctx->pb);

718 }

719 avformat_free_context(rtpctx);

720 } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)

721 ff_rdt_parse_close(rtsp_st->transport_priv);

722 else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)

723 ff_rtp_parse_close(rtsp_st->transport_priv);

724 }

725 rtsp_st->transport_priv = NULL;

726 if (rtsp_st->rtp_handle)

727 ffurl_close(rtsp_st->rtp_handle);

728 rtsp_st->rtp_handle = NULL;

729 }

730 }

731

732 /* close and free RTSP streams */

733 void ff_rtsp_close_streams(AVFormatContext *s)

734 {

735 RTSPState *rt = s->priv_data;

736 int i, j;

737 RTSPStream *rtsp_st;

738

739 ff_rtsp_undo_setup(s, 0);

740 for (i = 0; i < rt->nb_rtsp_streams; i++) {

741 rtsp_st = rt->rtsp_streams[i];

742 if (rtsp_st) {

743 if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) {

744 if (rtsp_st->dynamic_handler->close)

745 rtsp_st->dynamic_handler->close(

746 rtsp_st->dynamic_protocol_context);

747 av_free(rtsp_st->dynamic_protocol_context);

748 }

749 for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)

750 av_freep(&rtsp_st->include_source_addrs[j]);

751 av_freep(&rtsp_st->include_source_addrs);

752 for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)

753 av_freep(&rtsp_st->exclude_source_addrs[j]);

754 av_freep(&rtsp_st->exclude_source_addrs);

755

756 av_freep(&rtsp_st);

757 }

758 }

759 av_freep(&rt->rtsp_streams);

760 if (rt->asf_ctx) {

761 avformat_close_input(&rt->asf_ctx);

762 }

763 if (CONFIG_RTPDEC && rt->ts)

764 avpriv_mpegts_parse_close(rt->ts);

765 av_freep(&rt->p);

766 av_freep(&rt->recvbuf);

767 }

768

769 int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)

770 {

771 RTSPState *rt = s->priv_data;

772 AVStream *st = NULL;

773 int reordering_queue_size = rt->reordering_queue_size;

774 if (reordering_queue_size < 0) {

775 if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)

776 reordering_queue_size = 0;

777 else

778 reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;

779 }

780

781 /* open the RTP context */

782 if (rtsp_st->stream_index >= 0)

783 st = s->streams[rtsp_st->stream_index];

784 if (!st)

785 s->ctx_flags |= AVFMTCTX_NOHEADER;

786

787 if (CONFIG_RTSP_MUXER && s->oformat) {

788 int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,

789 s, st, rtsp_st->rtp_handle,

790 RTSP_TCP_MAX_PACKET_SIZE,

791 rtsp_st->stream_index);

792 /* Ownership of rtp_handle is passed to the rtp mux context */

793 rtsp_st->rtp_handle = NULL;

794 if (ret < 0)

795 return ret;

796 st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;

797 } else if (rt->transport == RTSP_TRANSPORT_RAW) {

798 return 0; // Don't need to open any parser here

799 } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)

800 rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,

801 rtsp_st->dynamic_protocol_context,

802 rtsp_st->dynamic_handler);

803 else if (CONFIG_RTPDEC)

804 rtsp_st->transport_priv = ff_rtp_parse_open(s, st,

805 rtsp_st->sdp_payload_type,

806 reordering_queue_size);

807

808 if (!rtsp_st->transport_priv) {

809 return AVERROR(ENOMEM);

810 } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) {

811 if (rtsp_st->dynamic_handler) {

812 ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,

813 rtsp_st->dynamic_protocol_context,

814 rtsp_st->dynamic_handler);

815 }

816 if (rtsp_st->crypto_suite[0])

817 ff_rtp_parse_set_crypto(rtsp_st->transport_priv,

818 rtsp_st->crypto_suite,

819 rtsp_st->crypto_params);

820 }

821

822 return 0;

823 }

824

825 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER

826 static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)

827 {

828 const char *q;

829 char *p;

830 int v;

831

832 q = *pp;

833 q += strspn(q, SPACE_CHARS);

834 v = strtol(q, &p, 10);

835 if (*p == '-') {

836 p++;

837 *min_ptr = v;

838 v = strtol(p, &p, 10);

839 *max_ptr = v;

840 } else {

841 *min_ptr = v;

842 *max_ptr = v;

843 }

844 *pp = p;

845 }

846

847 /* XXX: only one transport specification is parsed */

848 static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)

849 {

850 char transport_protocol[16];

851 char profile[16];

852 char lower_transport[16];

853 char parameter[16];

854 RTSPTransportField *th;

855 char buf[256];

856

857 reply->nb_transports = 0;

858

859 for (;;) {

860 p += strspn(p, SPACE_CHARS);

861 if (*p == '0円')

862 break;

863

864 th = &reply->transports[reply->nb_transports];

865

866 get_word_sep(transport_protocol, sizeof(transport_protocol),

867 "/", &p);

868 if (!av_strcasecmp (transport_protocol, "rtp")) {

869 get_word_sep(profile, sizeof(profile), "/;,", &p);

870 lower_transport[0] = '0円';

871 /* rtp/avp/<protocol> */

872 if (*p == '/') {

873 get_word_sep(lower_transport, sizeof(lower_transport),

874 ";,", &p);

875 }

876 th->transport = RTSP_TRANSPORT_RTP;

877 } else if (!av_strcasecmp (transport_protocol, "x-pn-tng") ||

878 !av_strcasecmp (transport_protocol, "x-real-rdt")) {

879 /* x-pn-tng/<protocol> */

880 get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);

881 profile[0] = '0円';

882 th->transport = RTSP_TRANSPORT_RDT;

883 } else if (!av_strcasecmp(transport_protocol, "raw")) {

884 get_word_sep(profile, sizeof(profile), "/;,", &p);

885 lower_transport[0] = '0円';

886 /* raw/raw/<protocol> */

887 if (*p == '/') {

888 get_word_sep(lower_transport, sizeof(lower_transport),

889 ";,", &p);

890 }

891 th->transport = RTSP_TRANSPORT_RAW;

892 }

893 if (!av_strcasecmp(lower_transport, "TCP"))

894 th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;

895 else

896 th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;

897

898 if (*p == ';')

899 p++;

900 /* get each parameter */

901 while (*p != '0円' && *p != ',') {

902 get_word_sep(parameter, sizeof(parameter), "=;,", &p);

903 if (!strcmp(parameter, "port")) {

904 if (*p == '=') {

905 p++;

906 rtsp_parse_range(&th->port_min, &th->port_max, &p);

907 }

908 } else if (!strcmp(parameter, "client_port")) {

909 if (*p == '=') {

910 p++;

911 rtsp_parse_range(&th->client_port_min,

912 &th->client_port_max, &p);

913 }

914 } else if (!strcmp(parameter, "server_port")) {

915 if (*p == '=') {

916 p++;

917 rtsp_parse_range(&th->server_port_min,

918 &th->server_port_max, &p);

919 }

920 } else if (!strcmp(parameter, "interleaved")) {

921 if (*p == '=') {

922 p++;

923 rtsp_parse_range(&th->interleaved_min,

924 &th->interleaved_max, &p);

925 }

926 } else if (!strcmp(parameter, "multicast")) {

927 if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)

928 th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;

929 } else if (!strcmp(parameter, "ttl")) {

930 if (*p == '=') {

931 char *end;

932 p++;

933 th->ttl = strtol(p, &end, 10);

934 p = end;

935 }

936 } else if (!strcmp(parameter, "destination")) {

937 if (*p == '=') {

938 p++;

939 get_word_sep(buf, sizeof(buf), ";,", &p);

940 get_sockaddr(buf, &th->destination);

941 }

942 } else if (!strcmp(parameter, "source")) {

943 if (*p == '=') {

944 p++;

945 get_word_sep(buf, sizeof(buf), ";,", &p);

946 av_strlcpy(th->source, buf, sizeof(th->source));

947 }

948 } else if (!strcmp(parameter, "mode")) {

949 if (*p == '=') {

950 p++;

951 get_word_sep(buf, sizeof(buf), ";, ", &p);

952 if (!strcmp(buf, "record") ||

953 !strcmp(buf, "receive"))

954 th->mode_record = 1;

955 }

956 }

957

958 while (*p != ';' && *p != '0円' && *p != ',')

959 p++;

960 if (*p == ';')

961 p++;

962 }

963 if (*p == ',')

964 p++;

965

966 reply->nb_transports++;

967 }

968 }

969

970 static void handle_rtp_info(RTSPState *rt, const char *url,

971 uint32_t seq, uint32_t rtptime)

972 {

973 int i;

974 if (!rtptime || !url[0])

975 return;

976 if (rt->transport != RTSP_TRANSPORT_RTP)

977 return;

978 for (i = 0; i < rt->nb_rtsp_streams; i++) {

979 RTSPStream *rtsp_st = rt->rtsp_streams[i];

980 RTPDemuxContext *rtpctx = rtsp_st->transport_priv;

981 if (!rtpctx)

982 continue;

983 if (!strcmp(rtsp_st->control_url, url)) {

984 rtpctx->base_timestamp = rtptime;

985 break;

986 }

987 }

988 }

989

990 static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)

991 {

992 int read = 0;

993 char key[20], value[1024], url[1024] = "";

994 uint32_t seq = 0, rtptime = 0;

995

996 for (;;) {

997 p += strspn(p, SPACE_CHARS);

998 if (!*p)

999 break;

1000 get_word_sep(key, sizeof(key), "=", &p);

1001 if (*p != '=')

1002 break;

1003 p++;

1004 get_word_sep(value, sizeof(value), ";, ", &p);

1005 read++;

1006 if (!strcmp(key, "url"))

1007 av_strlcpy(url, value, sizeof(url));

1008 else if (!strcmp(key, "seq"))

1009 seq = strtoul(value, NULL, 10);

1010 else if (!strcmp(key, "rtptime"))

1011 rtptime = strtoul(value, NULL, 10);

1012 if (*p == ',') {

1013 handle_rtp_info(rt, url, seq, rtptime);

1014 url[0] = '0円';

1015 seq = rtptime = 0;

1016 read = 0;

1017 }

1018 if (*p)

1019 p++;

1020 }

1021 if (read > 0)

1022 handle_rtp_info(rt, url, seq, rtptime);

1023 }

1024

1025 void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,

1026 RTSPState *rt, const char *method)

1027 {

1028 const char *p;

1029

1030 /* NOTE: we do case independent match for broken servers */

1031 p = buf;

1032 if (av_stristart(p, "Session:", &p)) {

1033 int t;

1034 get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);

1035 if (av_stristart(p, ";timeout=", &p) &&

1036 (t = strtol(p, NULL, 10)) > 0) {

1037 reply->timeout = t;

1038 }

1039 } else if (av_stristart(p, "Content-Length:", &p)) {

1040 reply->content_length = strtol(p, NULL, 10);

1041 } else if (av_stristart(p, "Transport:", &p)) {

1042 rtsp_parse_transport(reply, p);

1043 } else if (av_stristart(p, "CSeq:", &p)) {

1044 reply->seq = strtol(p, NULL, 10);

1045 } else if (av_stristart(p, "Range:", &p)) {

1046 rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);

1047 } else if (av_stristart(p, "RealChallenge1:", &p)) {

1048 p += strspn(p, SPACE_CHARS);

1049 av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));

1050 } else if (av_stristart(p, "Server:", &p)) {

1051 p += strspn(p, SPACE_CHARS);

1052 av_strlcpy(reply->server, p, sizeof(reply->server));

1053 } else if (av_stristart(p, "Notice:", &p) ||

1054 av_stristart(p, "X-Notice:", &p)) {

1055 reply->notice = strtol(p, NULL, 10);

1056 } else if (av_stristart(p, "Location:", &p)) {

1057 p += strspn(p, SPACE_CHARS);

1058 av_strlcpy(reply->location, p , sizeof(reply->location));

1059 } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {

1060 p += strspn(p, SPACE_CHARS);

1061 ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);

1062 } else if (av_stristart(p, "Authentication-Info:", &p) && rt) {

1063 p += strspn(p, SPACE_CHARS);

1064 ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);

1065 } else if (av_stristart(p, "Content-Base:", &p) && rt) {

1066 p += strspn(p, SPACE_CHARS);

1067 if (method && !strcmp(method, "DESCRIBE"))

1068 av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));

1069 } else if (av_stristart(p, "RTP-Info:", &p) && rt) {

1070 p += strspn(p, SPACE_CHARS);

1071 if (method && !strcmp(method, "PLAY"))

1072 rtsp_parse_rtp_info(rt, p);

1073 } else if (av_stristart(p, "Public:", &p) && rt) {

1074 if (strstr(p, "GET_PARAMETER") &&

1075 method && !strcmp(method, "OPTIONS"))

1076 rt->get_parameter_supported = 1;

1077 } else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {

1078 p += strspn(p, SPACE_CHARS);

1079 rt->accept_dynamic_rate = atoi(p);

1080 } else if (av_stristart(p, "Content-Type:", &p)) {

1081 p += strspn(p, SPACE_CHARS);

1082 av_strlcpy(reply->content_type, p, sizeof(reply->content_type));

1083 }

1084 }

1085

1086 /* skip a RTP/TCP interleaved packet */

1087 void ff_rtsp_skip_packet(AVFormatContext *s)

1088 {

1089 RTSPState *rt = s->priv_data;

1090 int ret, len, len1;

1091 uint8_t buf[1024];

1092

1093 ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);

1094 if (ret != 3)

1095 return;

1096 len = AV_RB16(buf + 1);

1097

1098 av_dlog(s, "skipping RTP packet len=%d\n", len);

1099

1100 /* skip payload */

1101 while (len > 0) {

1102 len1 = len;

1103 if (len1 > sizeof(buf))

1104 len1 = sizeof(buf);

1105 ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);

1106 if (ret != len1)

1107 return;

1108 len -= len1;

1109 }

1110 }

1111

1112 int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,

1113 unsigned char **content_ptr,

1114 int return_on_interleaved_data, const char *method)

1115 {

1116 RTSPState *rt = s->priv_data;

1117 char buf[4096], buf1[1024], *q;

1118 unsigned char ch;

1119 const char *p;

1120 int ret, content_length, line_count = 0, request = 0;

1121 unsigned char *content = NULL;

1122

1123 start:

1124 line_count = 0;

1125 request = 0;

1126 content = NULL;

1127 memset(reply, 0, sizeof(*reply));

1128

1129 /* parse reply (XXX: use buffers) */

1130 rt->last_reply[0] = '0円';

1131 for (;;) {

1132 q = buf;

1133 for (;;) {

1134 ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);

1135 av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);

1136 if (ret != 1)

1137 return AVERROR_EOF;

1138 if (ch == '\n')

1139 break;

1140 if (ch == '$') {

1141 /* XXX: only parse it if first char on line ? */

1142 if (return_on_interleaved_data) {

1143 return 1;

1144 } else

1145 ff_rtsp_skip_packet(s);

1146 } else if (ch != '\r') {

1147 if ((q - buf) < sizeof(buf) - 1)

1148 *q++ = ch;

1149 }

1150 }

1151 *q = '0円';

1152

1153 av_dlog(s, "line='%s'\n", buf);

1154

1155 /* test if last line */

1156 if (buf[0] == '0円')

1157 break;

1158 p = buf;

1159 if (line_count == 0) {

1160 /* get reply code */

1161 get_word(buf1, sizeof(buf1), &p);

1162 if (!strncmp(buf1, "RTSP/", 5)) {

1163 get_word(buf1, sizeof(buf1), &p);

1164 reply->status_code = atoi(buf1);

1165 av_strlcpy(reply->reason, p, sizeof(reply->reason));

1166 } else {

1167 av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method

1168 get_word(buf1, sizeof(buf1), &p); // object

1169 request = 1;

1170 }

1171 } else {

1172 ff_rtsp_parse_line(reply, p, rt, method);

1173 av_strlcat(rt->last_reply, p, sizeof(rt->last_reply));

1174 av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));

1175 }

1176 line_count++;

1177 }

1178

1179 if (rt->session_id[0] == '0円' && reply->session_id[0] != '0円' && !request)

1180 av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));

1181

1182 content_length = reply->content_length;

1183 if (content_length > 0) {

1184 /* leave some room for a trailing '0円' (useful for simple parsing) */

1185 content = av_malloc(content_length + 1);

1186 if (!content)

1187 return AVERROR(ENOMEM);

1188 ffurl_read_complete(rt->rtsp_hd, content, content_length);

1189 content[content_length] = '0円';

1190 }

1191 if (content_ptr)

1192 *content_ptr = content;

1193 else

1194 av_freep(&content);

1195

1196 if (request) {

1197 char buf[1024];

1198 char base64buf[AV_BASE64_SIZE(sizeof(buf))];

1199 const char* ptr = buf;

1200

1201 if (!strcmp(reply->reason, "OPTIONS")) {

1202 snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");

1203 if (reply->seq)

1204 av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);

1205 if (reply->session_id[0])

1206 av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",

1207 reply->session_id);

1208 } else {

1209 snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");

1210 }

1211 av_strlcat(buf, "\r\n", sizeof(buf));

1212

1213 if (rt->control_transport == RTSP_MODE_TUNNEL) {

1214 av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));

1215 ptr = base64buf;

1216 }

1217 ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));

1218

1219 rt->last_cmd_time = av_gettime_relative();

1220 /* Even if the request from the server had data, it is not the data

1221 * that the caller wants or expects. The memory could also be leaked

1222 * if the actual following reply has content data. */

1223 if (content_ptr)

1224 av_freep(content_ptr);

1225 /* If method is set, this is called from ff_rtsp_send_cmd,

1226 * where a reply to exactly this request is awaited. For

1227 * callers from within packet receiving, we just want to

1228 * return to the caller and go back to receiving packets. */

1229 if (method)

1230 goto start;

1231 return 0;

1232 }

1233

1234 if (rt->seq != reply->seq) {

1235 av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",

1236 rt->seq, reply->seq);

1237 }

1238

1239 /* EOS */

1240 if (reply->notice == 2101 /* End-of-Stream Reached */ ||

1241 reply->notice == 2104 /* Start-of-Stream Reached */ ||

1242 reply->notice == 2306 /* Continuous Feed Terminated */) {

1243 rt->state = RTSP_STATE_IDLE;

1244 } else if (reply->notice >= 4400 && reply->notice < 5500) {

1245 return AVERROR(EIO); /* data or server error */

1246 } else if (reply->notice == 2401 /* Ticket Expired */ ||

1247 (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )

1248 return AVERROR(EPERM);

1249

1250 return 0;

1251 }

1252

1253 /**

1254 * Send a command to the RTSP server without waiting for the reply.

1255 *

1256 * @param s RTSP (de)muxer context

1257 * @param method the method for the request

1258 * @param url the target url for the request

1259 * @param headers extra header lines to include in the request

1260 * @param send_content if non-null, the data to send as request body content

1261 * @param send_content_length the length of the send_content data, or 0 if

1262 * send_content is null

1263 *

1264 * @return zero if success, nonzero otherwise

1265 */

1266 static int rtsp_send_cmd_with_content_async(AVFormatContext *s,

1267 const char *method, const char *url,

1268 const char *headers,

1269 const unsigned char *send_content,

1270 int send_content_length)

1271 {

1272 RTSPState *rt = s->priv_data;

1273 char buf[4096], *out_buf;

1274 char base64buf[AV_BASE64_SIZE(sizeof(buf))];

1275

1276 /* Add in RTSP headers */

1277 out_buf = buf;

1278 rt->seq++;

1279 snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);

1280 if (headers)

1281 av_strlcat(buf, headers, sizeof(buf));

1282 av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);

1283 av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent);

1284 if (rt->session_id[0] != '0円' && (!headers ||

1285 !strstr(headers, "\nIf-Match:"))) {

1286 av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);

1287 }

1288 if (rt->auth[0]) {

1289 char *str = ff_http_auth_create_response(&rt->auth_state,

1290 rt->auth, url, method);

1291 if (str)

1292 av_strlcat(buf, str, sizeof(buf));

1293 av_free(str);

1294 }

1295 if (send_content_length > 0 && send_content)

1296 av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);

1297 av_strlcat(buf, "\r\n", sizeof(buf));

1298

1299 /* base64 encode rtsp if tunneling */

1300 if (rt->control_transport == RTSP_MODE_TUNNEL) {

1301 av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));

1302 out_buf = base64buf;

1303 }

1304

1305 av_dlog(s, "Sending:\n%s--\n", buf);

1306

1307 ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));

1308 if (send_content_length > 0 && send_content) {

1309 if (rt->control_transport == RTSP_MODE_TUNNEL) {

1310 av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "

1311 "with content data not supported\n");

1312 return AVERROR_PATCHWELCOME;

1313 }

1314 ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);

1315 }

1316 rt->last_cmd_time = av_gettime_relative();

1317

1318 return 0;

1319 }

1320

1321 int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,

1322 const char *url, const char *headers)

1323 {

1324 return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);

1325 }

1326

1327 int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,

1328 const char *headers, RTSPMessageHeader *reply,

1329 unsigned char **content_ptr)

1330 {

1331 return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,

1332 content_ptr, NULL, 0);

1333 }

1334

1335 int ff_rtsp_send_cmd_with_content(AVFormatContext *s,

1336 const char *method, const char *url,

1337 const char *header,

1338 RTSPMessageHeader *reply,

1339 unsigned char **content_ptr,

1340 const unsigned char *send_content,

1341 int send_content_length)

1342 {

1343 RTSPState *rt = s->priv_data;

1344 HTTPAuthType cur_auth_type;

1345 int ret, attempts = 0;

1346

1347 retry:

1348 cur_auth_type = rt->auth_state.auth_type;

1349 if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,

1350 send_content,

1351 send_content_length)))

1352 return ret;

1353

1354 if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)

1355 return ret;

1356 attempts++;

1357

1358 if (reply->status_code == 401 &&

1359 (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&

1360 rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)

1361 goto retry;

1362

1363 if (reply->status_code > 400){

1364 av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",

1365 method,

1366 reply->status_code,

1367 reply->reason);

1368 av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);

1369 }

1370

1371 return 0;

1372 }

1373

1374 int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,

1375 int lower_transport, const char *real_challenge)

1376 {

1377 RTSPState *rt = s->priv_data;

1378 int rtx = 0, j, i, err, interleave = 0, port_off;

1379 RTSPStream *rtsp_st;

1380 RTSPMessageHeader reply1, *reply = &reply1;

1381 char cmd[2048];

1382 const char *trans_pref;

1383

1384 if (rt->transport == RTSP_TRANSPORT_RDT)

1385 trans_pref = "x-pn-tng";

1386 else if (rt->transport == RTSP_TRANSPORT_RAW)

1387 trans_pref = "RAW/RAW";

1388 else

1389 trans_pref = "RTP/AVP";

1390

1391 /* default timeout: 1 minute */

1392 rt->timeout = 60;

1393

1394 /* Choose a random starting offset within the first half of the

1395 * port range, to allow for a number of ports to try even if the offset

1396 * happens to be at the end of the random range. */

1397 port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);

1398 /* even random offset */

1399 port_off -= port_off & 0x01;

1400

1401 for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {

1402 char transport[2048];

1403

1404 /*

1405 * WMS serves all UDP data over a single connection, the RTX, which

1406 * isn't necessarily the first in the SDP but has to be the first

1407 * to be set up, else the second/third SETUP will fail with a 461.

1408 */

1409 if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&

1410 rt->server_type == RTSP_SERVER_WMS) {

1411 if (i == 0) {

1412 /* rtx first */

1413 for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {

1414 int len = strlen(rt->rtsp_streams[rtx]->control_url);

1415 if (len >= 4 &&

1416 !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,

1417 "/rtx"))

1418 break;

1419 }

1420 if (rtx == rt->nb_rtsp_streams)

1421 return -1; /* no RTX found */

1422 rtsp_st = rt->rtsp_streams[rtx];

1423 } else

1424 rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];

1425 } else

1426 rtsp_st = rt->rtsp_streams[i];

1427

1428 /* RTP/UDP */

1429 if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {

1430 char buf[256];

1431

1432 if (rt->server_type == RTSP_SERVER_WMS && i > 1) {

1433 port = reply->transports[0].client_port_min;

1434 goto have_port;

1435 }

1436

1437 /* first try in specified port range */

1438 while (j <= rt->rtp_port_max) {

1439 ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,

1440 "?localport=%d", j);

1441 /* we will use two ports per rtp stream (rtp and rtcp) */

1442 j += 2;

1443 if (!ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,

1444 &s->interrupt_callback, NULL))

1445 goto rtp_opened;

1446 }

1447 av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");

1448 err = AVERROR(EIO);

1449 goto fail;

1450

1451 rtp_opened:

1452 port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);

1453 have_port:

1454 snprintf(transport, sizeof(transport) - 1,

1455 "%s/UDP;", trans_pref);

1456 if (rt->server_type != RTSP_SERVER_REAL)

1457 av_strlcat(transport, "unicast;", sizeof(transport));

1458 av_strlcatf(transport, sizeof(transport),

1459 "client_port=%d", port);

1460 if (rt->transport == RTSP_TRANSPORT_RTP &&

1461 !(rt->server_type == RTSP_SERVER_WMS && i > 0))

1462 av_strlcatf(transport, sizeof(transport), "-%d", port + 1);

1463 }

1464

1465 /* RTP/TCP */

1466 else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {

1467 /* For WMS streams, the application streams are only used for

1468 * UDP. When trying to set it up for TCP streams, the server

1469 * will return an error. Therefore, we skip those streams. */

1470 if (rt->server_type == RTSP_SERVER_WMS &&

1471 (rtsp_st->stream_index < 0 ||

1472 s->streams[rtsp_st->stream_index]->codec->codec_type ==

1473 AVMEDIA_TYPE_DATA))

1474 continue;

1475 snprintf(transport, sizeof(transport) - 1,

1476 "%s/TCP;", trans_pref);

1477 if (rt->transport != RTSP_TRANSPORT_RDT)

1478 av_strlcat(transport, "unicast;", sizeof(transport));

1479 av_strlcatf(transport, sizeof(transport),

1480 "interleaved=%d-%d",

1481 interleave, interleave + 1);

1482 interleave += 2;

1483 }

1484

1485 else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {

1486 snprintf(transport, sizeof(transport) - 1,

1487 "%s/UDP;multicast", trans_pref);

1488 }

1489 if (s->oformat) {

1490 av_strlcat(transport, ";mode=record", sizeof(transport));

1491 } else if (rt->server_type == RTSP_SERVER_REAL ||

1492 rt->server_type == RTSP_SERVER_WMS)

1493 av_strlcat(transport, ";mode=play", sizeof(transport));

1494 snprintf(cmd, sizeof(cmd),

1495 "Transport: %s\r\n",

1496 transport);

1497 if (rt->accept_dynamic_rate)

1498 av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));

1499 if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {

1500 char real_res[41], real_csum[9];

1501 ff_rdt_calc_response_and_checksum(real_res, real_csum,

1502 real_challenge);

1503 av_strlcatf(cmd, sizeof(cmd),

1504 "If-Match: %s\r\n"

1505 "RealChallenge2: %s, sd=%s\r\n",

1506 rt->session_id, real_res, real_csum);

1507 }

1508 ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);

1509 if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {

1510 err = 1;

1511 goto fail;

1512 } else if (reply->status_code != RTSP_STATUS_OK ||

1513 reply->nb_transports != 1) {

1514 err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);

1515 goto fail;

1516 }

1517

1518 /* XXX: same protocol for all streams is required */

1519 if (i > 0) {

1520 if (reply->transports[0].lower_transport != rt->lower_transport ||

1521 reply->transports[0].transport != rt->transport) {

1522 err = AVERROR_INVALIDDATA;

1523 goto fail;

1524 }

1525 } else {

1526 rt->lower_transport = reply->transports[0].lower_transport;

1527 rt->transport = reply->transports[0].transport;

1528 }

1529

1530 /* Fail if the server responded with another lower transport mode

1531 * than what we requested. */

1532 if (reply->transports[0].lower_transport != lower_transport) {

1533 av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");

1534 err = AVERROR_INVALIDDATA;

1535 goto fail;

1536 }

1537

1538 switch(reply->transports[0].lower_transport) {

1539 case RTSP_LOWER_TRANSPORT_TCP:

1540 rtsp_st->interleaved_min = reply->transports[0].interleaved_min;

1541 rtsp_st->interleaved_max = reply->transports[0].interleaved_max;

1542 break;

1543

1544 case RTSP_LOWER_TRANSPORT_UDP: {

1545 char url[1024], options[30] = "";

1546 const char *peer = host;

1547

1548 if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)

1549 av_strlcpy(options, "?connect=1", sizeof(options));

1550 /* Use source address if specified */

1551 if (reply->transports[0].source[0])

1552 peer = reply->transports[0].source;

1553 ff_url_join(url, sizeof(url), "rtp", NULL, peer,

1554 reply->transports[0].server_port_min, "%s", options);

1555 if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&

1556 ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {

1557 err = AVERROR_INVALIDDATA;

1558 goto fail;

1559 }

1560 break;

1561 }

1562 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {

1563 char url[1024], namebuf[50], optbuf[20] = "";

1564 struct sockaddr_storage addr;

1565 int port, ttl;

1566

1567 if (reply->transports[0].destination.ss_family) {

1568 addr = reply->transports[0].destination;

1569 port = reply->transports[0].port_min;

1570 ttl = reply->transports[0].ttl;

1571 } else {

1572 addr = rtsp_st->sdp_ip;

1573 port = rtsp_st->sdp_port;

1574 ttl = rtsp_st->sdp_ttl;

1575 }

1576 if (ttl > 0)

1577 snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);

1578 getnameinfo((struct sockaddr*) &addr, sizeof(addr),

1579 namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);

1580 ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,

1581 port, "%s", optbuf);

1582 if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,

1583 &s->interrupt_callback, NULL) < 0) {

1584 err = AVERROR_INVALIDDATA;

1585 goto fail;

1586 }

1587 break;

1588 }

1589 }

1590

1591 if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))

1592 goto fail;

1593 }

1594

1595 if (rt->nb_rtsp_streams && reply->timeout > 0)

1596 rt->timeout = reply->timeout;

1597

1598 if (rt->server_type == RTSP_SERVER_REAL)

1599 rt->need_subscription = 1;

1600

1601 return 0;

1602

1603 fail:

1604 ff_rtsp_undo_setup(s, 0);

1605 return err;

1606 }

1607

1608 void ff_rtsp_close_connections(AVFormatContext *s)

1609 {

1610 RTSPState *rt = s->priv_data;

1611 if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out);

1612 ffurl_close(rt->rtsp_hd);

1613 rt->rtsp_hd = rt->rtsp_hd_out = NULL;

1614 }

1615

1616 int ff_rtsp_connect(AVFormatContext *s)

1617 {

1618 RTSPState *rt = s->priv_data;

1619 char proto[128], host[1024], path[1024];

1620 char tcpname[1024], cmd[2048], auth[128];

1621 const char *lower_rtsp_proto = "tcp";

1622 int port, err, tcp_fd;

1623 RTSPMessageHeader reply1 = {0}, *reply = &reply1;

1624 int lower_transport_mask = 0;

1625 int default_port = RTSP_DEFAULT_PORT;

1626 char real_challenge[64] = "";

1627 struct sockaddr_storage peer;

1628 socklen_t peer_len = sizeof(peer);

1629

1630 if (rt->rtp_port_max < rt->rtp_port_min) {

1631 av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "

1632 "than min port %d\n", rt->rtp_port_max,

1633 rt->rtp_port_min);

1634 return AVERROR(EINVAL);

1635 }

1636

1637 if (!ff_network_init())

1638 return AVERROR(EIO);

1639

1640 if (s->max_delay < 0) /* Not set by the caller */

1641 s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;

1642

1643 rt->control_transport = RTSP_MODE_PLAIN;

1644 if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) {

1645 rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;

1646 rt->control_transport = RTSP_MODE_TUNNEL;

1647 }

1648 /* Only pass through valid flags from here */

1649 rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;

1650

1651 redirect:

1652 /* extract hostname and port */

1653 av_url_split(proto, sizeof(proto), auth, sizeof(auth),

1654 host, sizeof(host), &port, path, sizeof(path), s->filename);

1655

1656 if (!strcmp(proto, "rtsps")) {

1657 lower_rtsp_proto = "tls";

1658 default_port = RTSPS_DEFAULT_PORT;

1659 rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;

1660 }

1661

1662 if (*auth) {

1663 av_strlcpy(rt->auth, auth, sizeof(rt->auth));

1664 }

1665 if (port < 0)

1666 port = default_port;

1667

1668 lower_transport_mask = rt->lower_transport_mask;

1669

1670 if (!lower_transport_mask)

1671 lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;

1672

1673 if (s->oformat) {

1674 /* Only UDP or TCP - UDP multicast isn't supported. */

1675 lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |

1676 (1 << RTSP_LOWER_TRANSPORT_TCP);

1677 if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {

1678 av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "

1679 "only UDP and TCP are supported for output.\n");

1680 err = AVERROR(EINVAL);

1681 goto fail;

1682 }

1683 }

1684

1685 /* Construct the URI used in request; this is similar to s->filename,

1686 * but with authentication credentials removed and RTSP specific options

1687 * stripped out. */

1688 ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,

1689 host, port, "%s", path);

1690

1691 if (rt->control_transport == RTSP_MODE_TUNNEL) {

1692 /* set up initial handshake for tunneling */

1693 char httpname[1024];

1694 char sessioncookie[17];

1695 char headers[1024];

1696

1697 ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);

1698 snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",

1699 av_get_random_seed(), av_get_random_seed());

1700

1701 /* GET requests */

1702 if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,

1703 &s->interrupt_callback) < 0) {

1704 err = AVERROR(EIO);

1705 goto fail;

1706 }

1707

1708 /* generate GET headers */

1709 snprintf(headers, sizeof(headers),

1710 "x-sessioncookie: %s\r\n"

1711 "Accept: application/x-rtsp-tunnelled\r\n"

1712 "Pragma: no-cache\r\n"

1713 "Cache-Control: no-cache\r\n",

1714 sessioncookie);

1715 av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);

1716

1717 /* complete the connection */

1718 if (ffurl_connect(rt->rtsp_hd, NULL)) {

1719 err = AVERROR(EIO);

1720 goto fail;

1721 }

1722

1723 /* POST requests */

1724 if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,

1725 &s->interrupt_callback) < 0 ) {

1726 err = AVERROR(EIO);

1727 goto fail;

1728 }

1729

1730 /* generate POST headers */

1731 snprintf(headers, sizeof(headers),

1732 "x-sessioncookie: %s\r\n"

1733 "Content-Type: application/x-rtsp-tunnelled\r\n"

1734 "Pragma: no-cache\r\n"

1735 "Cache-Control: no-cache\r\n"

1736 "Content-Length: 32767\r\n"

1737 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",

1738 sessioncookie);

1739 av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);

1740 av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);

1741

1742 /* Initialize the authentication state for the POST session. The HTTP

1743 * protocol implementation doesn't properly handle multi-pass

1744 * authentication for POST requests, since it would require one of

1745 * the following:

1746 * - implementing Expect: 100-continue, which many HTTP servers

1747 * don't support anyway, even less the RTSP servers that do HTTP

1748 * tunneling

1749 * - sending the whole POST data until getting a 401 reply specifying

1750 * what authentication method to use, then resending all that data

1751 * - waiting for potential 401 replies directly after sending the

1752 * POST header (waiting for some unspecified time)

1753 * Therefore, we copy the full auth state, which works for both basic

1754 * and digest. (For digest, we would have to synchronize the nonce

1755 * count variable between the two sessions, if we'd do more requests

1756 * with the original session, though.)

1757 */

1758 ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);

1759

1760 /* complete the connection */

1761 if (ffurl_connect(rt->rtsp_hd_out, NULL)) {

1762 err = AVERROR(EIO);

1763 goto fail;

1764 }

1765 } else {

1766 int ret;

1767 /* open the tcp connection */

1768 ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,

1769 host, port,

1770 "?timeout=%d", rt->stimeout);

1771 if ((ret = ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,

1772 &s->interrupt_callback, NULL)) < 0) {

1773 err = ret;

1774 goto fail;

1775 }

1776 rt->rtsp_hd_out = rt->rtsp_hd;

1777 }

1778 rt->seq = 0;

1779

1780 tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);

1781 if (tcp_fd < 0) {

1782 err = tcp_fd;

1783 goto fail;

1784 }

1785 if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {

1786 getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),

1787 NULL, 0, NI_NUMERICHOST);

1788 }

1789

1790 /* request options supported by the server; this also detects server

1791 * type */

1792 for (rt->server_type = RTSP_SERVER_RTP;;) {

1793 cmd[0] = 0;

1794 if (rt->server_type == RTSP_SERVER_REAL)

1795 av_strlcat(cmd,

1796 /*

1797 * The following entries are required for proper

1798 * streaming from a Realmedia server. They are

1799 * interdependent in some way although we currently

1800 * don't quite understand how. Values were copied

1801 * from mplayer SVN r23589.

1802 * ClientChallenge is a 16-byte ID in hex

1803 * CompanyID is a 16-byte ID in base64

1804 */

1805 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"

1806 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"

1807 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"

1808 "GUID: 00000000-0000-0000-0000-000000000000\r\n",

1809 sizeof(cmd));

1810 ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);

1811 if (reply->status_code != RTSP_STATUS_OK) {

1812 err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);

1813 goto fail;

1814 }

1815

1816 /* detect server type if not standard-compliant RTP */

1817 if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {

1818 rt->server_type = RTSP_SERVER_REAL;

1819 continue;

1820 } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {

1821 rt->server_type = RTSP_SERVER_WMS;

1822 } else if (rt->server_type == RTSP_SERVER_REAL)

1823 strcpy(real_challenge, reply->real_challenge);

1824 break;

1825 }

1826

1827 if (CONFIG_RTSP_DEMUXER && s->iformat)

1828 err = ff_rtsp_setup_input_streams(s, reply);

1829 else if (CONFIG_RTSP_MUXER)

1830 err = ff_rtsp_setup_output_streams(s, host);

1831 else

1832 av_assert0(0);

1833 if (err)

1834 goto fail;

1835

1836 do {

1837 int lower_transport = ff_log2_tab[lower_transport_mask &

1838 ~(lower_transport_mask - 1)];

1839

1840 if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))

1841 && (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))

1842 lower_transport = RTSP_LOWER_TRANSPORT_TCP;

1843

1844 err = ff_rtsp_make_setup_request(s, host, port, lower_transport,

1845 rt->server_type == RTSP_SERVER_REAL ?

1846 real_challenge : NULL);

1847 if (err < 0)

1848 goto fail;

1849 lower_transport_mask &= ~(1 << lower_transport);

1850 if (lower_transport_mask == 0 && err == 1) {

1851 err = AVERROR(EPROTONOSUPPORT);

1852 goto fail;

1853 }

1854 } while (err);

1855

1856 rt->lower_transport_mask = lower_transport_mask;

1857 av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));

1858 rt->state = RTSP_STATE_IDLE;

1859 rt->seek_timestamp = 0; /* default is to start stream at position zero */

1860 return 0;

1861 fail:

1862 ff_rtsp_close_streams(s);

1863 ff_rtsp_close_connections(s);

1864 if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {

1865 av_strlcpy(s->filename, reply->location, sizeof(s->filename));

1866 rt->session_id[0] = '0円';

1867 av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",

1868 reply->status_code,

1869 s->filename);

1870 goto redirect;

1871 }

1872 ff_network_close();

1873 return err;

1874 }

1875 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */

1876

1877 #if CONFIG_RTPDEC

1878 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,

1879 uint8_t *buf, int buf_size, int64_t wait_end)

1880 {

1881 RTSPState *rt = s->priv_data;

1882 RTSPStream *rtsp_st;

1883 int n, i, ret, tcp_fd, timeout_cnt = 0;

1884 int max_p = 0;

1885 struct pollfd *p = rt->p;

1886 int *fds = NULL, fdsnum, fdsidx;

1887

1888 for (;;) {

1889 if (ff_check_interrupt(&s->interrupt_callback))

1890 return AVERROR_EXIT;

1891 if (wait_end && wait_end - av_gettime_relative() < 0)

1892 return AVERROR(EAGAIN);

1893 max_p = 0;

1894 if (rt->rtsp_hd) {

1895 tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);

1896 p[max_p].fd = tcp_fd;

1897 p[max_p++].events = POLLIN;

1898 } else {

1899 tcp_fd = -1;

1900 }

1901 for (i = 0; i < rt->nb_rtsp_streams; i++) {

1902 rtsp_st = rt->rtsp_streams[i];

1903 if (rtsp_st->rtp_handle) {

1904 if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,

1905 &fds, &fdsnum)) {

1906 av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");

1907 return ret;

1908 }

1909 if (fdsnum != 2) {

1910 av_log(s, AV_LOG_ERROR,

1911 "Number of fds %d not supported\n", fdsnum);

1912 return AVERROR_INVALIDDATA;

1913 }

1914 for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {

1915 p[max_p].fd = fds[fdsidx];

1916 p[max_p++].events = POLLIN;

1917 }

1918 av_freep(&fds);

1919 }

1920 }

1921 n = poll(p, max_p, POLL_TIMEOUT_MS);

1922 if (n > 0) {

1923 int j = 1 - (tcp_fd == -1);

1924 timeout_cnt = 0;

1925 for (i = 0; i < rt->nb_rtsp_streams; i++) {

1926 rtsp_st = rt->rtsp_streams[i];

1927 if (rtsp_st->rtp_handle) {

1928 if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {

1929 ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);

1930 if (ret > 0) {

1931 *prtsp_st = rtsp_st;

1932 return ret;

1933 }

1934 }

1935 j+=2;

1936 }

1937 }

1938 #if CONFIG_RTSP_DEMUXER

1939 if (tcp_fd != -1 && p[0].revents & POLLIN) {

1940 if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {

1941 if (rt->state == RTSP_STATE_STREAMING) {

1942 if (!ff_rtsp_parse_streaming_commands(s))

1943 return AVERROR_EOF;

1944 else

1945 av_log(s, AV_LOG_WARNING,

1946 "Unable to answer to TEARDOWN\n");

1947 } else

1948 return 0;

1949 } else {

1950 RTSPMessageHeader reply;

1951 ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);

1952 if (ret < 0)

1953 return ret;

1954 /* XXX: parse message */

1955 if (rt->state != RTSP_STATE_STREAMING)

1956 return 0;

1957 }

1958 }

1959 #endif

1960 } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {

1961 return AVERROR(ETIMEDOUT);

1962 } else if (n < 0 && errno != EINTR)

1963 return AVERROR(errno);

1964 }

1965 }

1966

1967 static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,

1968 const uint8_t *buf, int len)

1969 {

1970 RTSPState *rt = s->priv_data;

1971 int i;

1972 if (len < 0)

1973 return len;

1974 if (rt->nb_rtsp_streams == 1) {

1975 *rtsp_st = rt->rtsp_streams[0];

1976 return len;

1977 }

1978 if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {

1979 if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {

1980 int no_ssrc = 0;

1981 for (i = 0; i < rt->nb_rtsp_streams; i++) {

1982 RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;

1983 if (!rtpctx)

1984 continue;

1985 if (rtpctx->ssrc == AV_RB32(&buf[4])) {

1986 *rtsp_st = rt->rtsp_streams[i];

1987 return len;

1988 }

1989 if (!rtpctx->ssrc)

1990 no_ssrc = 1;

1991 }

1992 if (no_ssrc) {

1993 av_log(s, AV_LOG_WARNING,

1994 "Unable to pick stream for packet - SSRC not known for "

1995 "all streams\n");

1996 return AVERROR(EAGAIN);

1997 }

1998 } else {

1999 for (i = 0; i < rt->nb_rtsp_streams; i++) {

2000 if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {

2001 *rtsp_st = rt->rtsp_streams[i];

2002 return len;

2003 }

2004 }

2005 }

2006 }

2007 av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");

2008 return AVERROR(EAGAIN);

2009 }

2010

2011 int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)

2012 {

2013 RTSPState *rt = s->priv_data;

2014 int ret, len;

2015 RTSPStream *rtsp_st, *first_queue_st = NULL;

2016 int64_t wait_end = 0;

2017

2018 if (rt->nb_byes == rt->nb_rtsp_streams)

2019 return AVERROR_EOF;

2020

2021 /* get next frames from the same RTP packet */

2022 if (rt->cur_transport_priv) {

2023 if (rt->transport == RTSP_TRANSPORT_RDT) {

2024 ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);

2025 } else if (rt->transport == RTSP_TRANSPORT_RTP) {

2026 ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);

2027 } else if (CONFIG_RTPDEC && rt->ts) {

2028 ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);

2029 if (ret >= 0) {

2030 rt->recvbuf_pos += ret;

2031 ret = rt->recvbuf_pos < rt->recvbuf_len;

2032 }

2033 } else

2034 ret = -1;

2035 if (ret == 0) {

2036 rt->cur_transport_priv = NULL;

2037 return 0;

2038 } else if (ret == 1) {

2039 return 0;

2040 } else

2041 rt->cur_transport_priv = NULL;

2042 }

2043

2044 redo:

2045 if (rt->transport == RTSP_TRANSPORT_RTP) {

2046 int i;

2047 int64_t first_queue_time = 0;

2048 for (i = 0; i < rt->nb_rtsp_streams; i++) {

2049 RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;

2050 int64_t queue_time;

2051 if (!rtpctx)

2052 continue;

2053 queue_time = ff_rtp_queued_packet_time(rtpctx);

2054 if (queue_time && (queue_time - first_queue_time < 0 ||

2055 !first_queue_time)) {

2056 first_queue_time = queue_time;

2057 first_queue_st = rt->rtsp_streams[i];

2058 }

2059 }

2060 if (first_queue_time) {

2061 wait_end = first_queue_time + s->max_delay;

2062 } else {

2063 wait_end = 0;

2064 first_queue_st = NULL;

2065 }

2066 }

2067

2068 /* read next RTP packet */

2069 if (!rt->recvbuf) {

2070 rt->recvbuf = av_malloc(RECVBUF_SIZE);

2071 if (!rt->recvbuf)

2072 return AVERROR(ENOMEM);

2073 }

2074

2075 switch(rt->lower_transport) {

2076 default:

2077 #if CONFIG_RTSP_DEMUXER

2078 case RTSP_LOWER_TRANSPORT_TCP:

2079 len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);

2080 break;

2081 #endif

2082 case RTSP_LOWER_TRANSPORT_UDP:

2083 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:

2084 len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);

2085 if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)

2086 ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);

2087 break;

2088 case RTSP_LOWER_TRANSPORT_CUSTOM:

2089 if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&

2090 wait_end && wait_end < av_gettime_relative())

2091 len = AVERROR(EAGAIN);

2092 else

2093 len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);

2094 len = pick_stream(s, &rtsp_st, rt->recvbuf, len);

2095 if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)

2096 ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len);

2097 break;

2098 }

2099 if (len == AVERROR(EAGAIN) && first_queue_st &&

2100 rt->transport == RTSP_TRANSPORT_RTP) {

2101 rtsp_st = first_queue_st;

2102 ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);

2103 goto end;

2104 }

2105 if (len < 0)

2106 return len;

2107 if (len == 0)

2108 return AVERROR_EOF;

2109 if (rt->transport == RTSP_TRANSPORT_RDT) {

2110 ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);

2111 } else if (rt->transport == RTSP_TRANSPORT_RTP) {

2112 ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);

2113 if (rtsp_st->feedback) {

2114 AVIOContext *pb = NULL;

2115 if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)

2116 pb = s->pb;

2117 ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);

2118 }

2119 if (ret < 0) {

2120 /* Either bad packet, or a RTCP packet. Check if the

2121 * first_rtcp_ntp_time field was initialized. */

2122 RTPDemuxContext *rtpctx = rtsp_st->transport_priv;

2123 if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {

2124 /* first_rtcp_ntp_time has been initialized for this stream,

2125 * copy the same value to all other uninitialized streams,

2126 * in order to map their timestamp origin to the same ntp time

2127 * as this one. */

2128 int i;

2129 AVStream *st = NULL;

2130 if (rtsp_st->stream_index >= 0)

2131 st = s->streams[rtsp_st->stream_index];

2132 for (i = 0; i < rt->nb_rtsp_streams; i++) {

2133 RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;

2134 AVStream *st2 = NULL;

2135 if (rt->rtsp_streams[i]->stream_index >= 0)

2136 st2 = s->streams[rt->rtsp_streams[i]->stream_index];

2137 if (rtpctx2 && st && st2 &&

2138 rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {

2139 rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;

2140 rtpctx2->rtcp_ts_offset = av_rescale_q(

2141 rtpctx->rtcp_ts_offset, st->time_base,

2142 st2->time_base);

2143 }

2144 }

2145 // Make real NTP start time available in AVFormatContext

2146 if (s->start_time_realtime == AV_NOPTS_VALUE) {

2147 s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32);

2148 if (rtpctx->st) {

2149 s->start_time_realtime -=

2150 av_rescale (rtpctx->rtcp_ts_offset,

2151 (uint64_t) rtpctx->st->time_base.num * 1000000,

2152 rtpctx->st->time_base.den);

2153 }

2154 }

2155 }

2156 if (ret == -RTCP_BYE) {

2157 rt->nb_byes++;

2158

2159 av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",

2160 rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);

2161

2162 if (rt->nb_byes == rt->nb_rtsp_streams)

2163 return AVERROR_EOF;

2164 }

2165 }

2166 } else if (CONFIG_RTPDEC && rt->ts) {

2167 ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);

2168 if (ret >= 0) {

2169 if (ret < len) {

2170 rt->recvbuf_len = len;

2171 rt->recvbuf_pos = ret;

2172 rt->cur_transport_priv = rt->ts;

2173 return 1;

2174 } else {

2175 ret = 0;

2176 }

2177 }

2178 } else {

2179 return AVERROR_INVALIDDATA;

2180 }

2181 end:

2182 if (ret < 0)

2183 goto redo;

2184 if (ret == 1)

2185 /* more packets may follow, so we save the RTP context */

2186 rt->cur_transport_priv = rtsp_st->transport_priv;

2187

2188 return ret;

2189 }

2190 #endif /* CONFIG_RTPDEC */

2191

2192 #if CONFIG_SDP_DEMUXER

2193 static int sdp_probe(AVProbeData *p1)

2194 {

2195 const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;

2196

2197 /* we look for a line beginning "c=IN IP" */

2198 while (p < p_end && *p != '0円') {

2199 if (p + sizeof("c=IN IP") - 1 < p_end &&

2200 av_strstart(p, "c=IN IP", NULL))

2201 return AVPROBE_SCORE_EXTENSION;

2202

2203 while (p < p_end - 1 && *p != '\n') p++;

2204 if (++p >= p_end)

2205 break;

2206 if (*p == '\r')

2207 p++;

2208 }

2209 return 0;

2210 }

2211

2212 static void append_source_addrs(char *buf, int size, const char *name,

2213 int count, struct RTSPSource **addrs)

2214 {

2215 int i;

2216 if (!count)

2217 return;

2218 av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);

2219 for (i = 1; i < count; i++)

2220 av_strlcatf(buf, size, ",%s", addrs[i]->addr);

2221 }

2222

2223 static int sdp_read_header(AVFormatContext *s)

2224 {

2225 RTSPState *rt = s->priv_data;

2226 RTSPStream *rtsp_st;

2227 int size, i, err;

2228 char *content;

2229 char url[1024];

2230

2231 if (!ff_network_init())

2232 return AVERROR(EIO);

2233

2234 if (s->max_delay < 0) /* Not set by the caller */

2235 s->max_delay = DEFAULT_REORDERING_DELAY;

2236 if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)

2237 rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;

2238

2239 /* read the whole sdp file */

2240 /* XXX: better loading */

2241 content = av_malloc(SDP_MAX_SIZE);

2242 size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);

2243 if (size <= 0) {

2244 av_free(content);

2245 return AVERROR_INVALIDDATA;

2246 }

2247 content[size] ='0円';

2248

2249 err = ff_sdp_parse(s, content);

2250 av_freep(&content);

2251 if (err) goto fail;

2252

2253 /* open each RTP stream */

2254 for (i = 0; i < rt->nb_rtsp_streams; i++) {

2255 char namebuf[50];

2256 rtsp_st = rt->rtsp_streams[i];

2257

2258 if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {

2259 getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),

2260 namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);

2261 ff_url_join(url, sizeof(url), "rtp", NULL,

2262 namebuf, rtsp_st->sdp_port,

2263 "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",

2264 rtsp_st->sdp_port, rtsp_st->sdp_ttl,

2265 rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,

2266 rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);

2267

2268 append_source_addrs(url, sizeof(url), "sources",

2269 rtsp_st->nb_include_source_addrs,

2270 rtsp_st->include_source_addrs);

2271 append_source_addrs(url, sizeof(url), "block",

2272 rtsp_st->nb_exclude_source_addrs,

2273 rtsp_st->exclude_source_addrs);

2274 if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,

2275 &s->interrupt_callback, NULL) < 0) {

2276 err = AVERROR_INVALIDDATA;

2277 goto fail;

2278 }

2279 }

2280 if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))

2281 goto fail;

2282 }

2283 return 0;

2284 fail:

2285 ff_rtsp_close_streams(s);

2286 ff_network_close();

2287 return err;

2288 }

2289

2290 static int sdp_read_close(AVFormatContext *s)

2291 {

2292 ff_rtsp_close_streams(s);

2293 ff_network_close();

2294 return 0;

2295 }

2296

2297 static const AVClass sdp_demuxer_class = {

2298 .class_name = "SDP demuxer",

2299 .item_name = av_default_item_name,

2300 .option = sdp_options,

2301 .version = LIBAVUTIL_VERSION_INT,

2302 };

2303

2304 AVInputFormat ff_sdp_demuxer = {

2305 .name = "sdp",

2306 .long_name = NULL_IF_CONFIG_SMALL("SDP"),

2307 .priv_data_size = sizeof(RTSPState),

2308 .read_probe = sdp_probe,

2309 .read_header = sdp_read_header,

2310 .read_packet = ff_rtsp_fetch_packet,

2311 .read_close = sdp_read_close,

2312 .priv_class = &sdp_demuxer_class,

2313 };

2314 #endif /* CONFIG_SDP_DEMUXER */

2315

2316 #if CONFIG_RTP_DEMUXER

2317 static int rtp_probe(AVProbeData *p)

2318 {

2319 if (av_strstart(p->filename, "rtp:", NULL))

2320 return AVPROBE_SCORE_MAX;

2321 return 0;

2322 }

2323

2324 static int rtp_read_header(AVFormatContext *s)

2325 {

2326 uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];

2327 char host[500], sdp[500];

2328 int ret, port;

2329 URLContext* in = NULL;

2330 int payload_type;

2331 AVCodecContext codec = { 0 };

2332 struct sockaddr_storage addr;

2333 AVIOContext pb;

2334 socklen_t addrlen = sizeof(addr);

2335 RTSPState *rt = s->priv_data;

2336

2337 if (!ff_network_init())

2338 return AVERROR(EIO);

2339

2340 ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ,

2341 &s->interrupt_callback, NULL);

2342 if (ret)

2343 goto fail;

2344

2345 while (1) {

2346 ret = ffurl_read(in, recvbuf, sizeof(recvbuf));

2347 if (ret == AVERROR(EAGAIN))

2348 continue;

2349 if (ret < 0)

2350 goto fail;

2351 if (ret < 12) {

2352 av_log(s, AV_LOG_WARNING, "Received too short packet\n");

2353 continue;

2354 }

2355

2356 if ((recvbuf[0] & 0xc0) != 0x80) {

2357 av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "

2358 "received\n");

2359 continue;

2360 }

2361

2362 if (RTP_PT_IS_RTCP(recvbuf[1]))

2363 continue;

2364

2365 payload_type = recvbuf[1] & 0x7f;

2366 break;

2367 }

2368 getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);

2369 ffurl_close(in);

2370 in = NULL;

2371

2372 if (ff_rtp_get_codec_info(&codec, payload_type)) {

2373 av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "

2374 "without an SDP file describing it\n",

2375 payload_type);

2376 goto fail;

2377 }

2378 if (codec.codec_type != AVMEDIA_TYPE_DATA) {

2379 av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "

2380 "properly you need an SDP file "

2381 "describing it\n");

2382 }

2383

2384 av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,

2385 NULL, 0, s->filename);

2386

2387 snprintf(sdp, sizeof(sdp),

2388 "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",

2389 addr.ss_family == AF_INET ? 4 : 6, host,

2390 codec.codec_type == AVMEDIA_TYPE_DATA ? "application" :

2391 codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",

2392 port, payload_type);

2393 av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);

2394

2395 ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);

2396 s->pb = &pb;

2397

2398 /* sdp_read_header initializes this again */

2399 ff_network_close();

2400

2401 rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;

2402

2403 ret = sdp_read_header(s);

2404 s->pb = NULL;

2405 return ret;

2406

2407 fail:

2408 if (in)

2409 ffurl_close(in);

2410 ff_network_close();

2411 return ret;

2412 }

2413

2414 static const AVClass rtp_demuxer_class = {

2415 .class_name = "RTP demuxer",

2416 .item_name = av_default_item_name,

2417 .option = rtp_options,

2418 .version = LIBAVUTIL_VERSION_INT,

2419 };

2420

2421 AVInputFormat ff_rtp_demuxer = {

2422 .name = "rtp",

2423 .long_name = NULL_IF_CONFIG_SMALL("RTP input"),

2424 .priv_data_size = sizeof(RTSPState),

2425 .read_probe = rtp_probe,

2426 .read_header = rtp_read_header,

2427 .read_packet = ff_rtsp_fetch_packet,

2428 .read_close = sdp_read_close,

2429 .flags = AVFMT_NOFILE,

2430 .priv_class = &rtp_demuxer_class,

2431 };

2432 #endif /* CONFIG_RTP_DEMUXER */

Generated on Sun Mar 8 2015 02:35:12 for FFmpeg by doxygen 1.8.2