FFmpeg: libavformat/rtpproto.c Source File

FFmpeg

[フレーム]

libavformat

rtpproto.c

Go to the documentation of this file.

1 /*

2 * RTP network protocol

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

23 * @file

24 * RTP protocol

25 */

27 #include "libavutil/parseutils.h"

28 #include "libavutil/avstring.h"

29 #include "avformat.h"

30 #include "avio_internal.h"

31 #include "rtp.h"

32 #include "rtpproto.h"

33 #include "url.h"

35 #include <stdarg.h>

36 #include "internal.h"

37 #include "network.h"

38 #include "os_support.h"

39 #include <fcntl.h>

40 #if HAVE_POLL_H

41 #include <sys/poll.h>

42 #endif

44 typedef struct RTPContext {

45 URLContext *rtp_hd, *rtcp_hd;

46 int rtp_fd, rtcp_fd, nb_ssm_include_addrs, nb_ssm_exclude_addrs;

47 struct sockaddr_storage **ssm_include_addrs, **ssm_exclude_addrs;

48 int write_to_source;

49 struct sockaddr_storage last_rtp_source, last_rtcp_source;

50 socklen_t last_rtp_source_len, last_rtcp_source_len;

51 } RTPContext;

53 /**

54 * If no filename is given to av_open_input_file because you want to

55 * get the local port first, then you must call this function to set

56 * the remote server address.

57 *

58 * @param h media file context

59 * @param uri of the remote server

60 * @return zero if no error.

61 */

63 int ff_rtp_set_remote_url(URLContext *h, const char *uri)

64 {

65 RTPContext *s = h->priv_data;

66 char hostname[256];

67 int port, rtcp_port;

68 const char *p;

70 char buf[1024];

71 char path[1024];

73 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port,

74 path, sizeof(path), uri);

75 rtcp_port = port + 1;

77 p = strchr(uri, '?');

78 if (p) {

79 if (av_find_info_tag(buf, sizeof(buf), "rtcpport", p)) {

80 rtcp_port = strtol(buf, NULL, 10);

81 }

82 }

84 ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port, "%s", path);

85 ff_udp_set_remote_url(s->rtp_hd, buf);

87 ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, rtcp_port, "%s", path);

88 ff_udp_set_remote_url(s->rtcp_hd, buf);

89 return 0;

90 }

92 static struct addrinfo* rtp_resolve_host(const char *hostname, int port,

93 int type, int family, int flags)

94 {

95 struct addrinfo hints = { 0 }, *res = 0;

96 int error;

97 char service[16];

99 snprintf(service, sizeof(service), "%d", port);

100 hints.ai_socktype = type;

101 hints.ai_family = family;

102 hints.ai_flags = flags;

103 if ((error = getaddrinfo(hostname, service, &hints, &res))) {

104 res = NULL;

105 av_log(NULL, AV_LOG_ERROR, "rtp_resolve_host: %s\n", gai_strerror(error));

106 }

107

108 return res;

109 }

110

111 static int compare_addr(const struct sockaddr_storage *a,

112 const struct sockaddr_storage *b)

113 {

114 if (a->ss_family != b->ss_family)

115 return 1;

116 if (a->ss_family == AF_INET) {

117 return (((const struct sockaddr_in *)a)->sin_addr.s_addr !=

118 ((const struct sockaddr_in *)b)->sin_addr.s_addr);

119 }

120

121 #if HAVE_STRUCT_SOCKADDR_IN6

122 if (a->ss_family == AF_INET6) {

123 const uint8_t *s6_addr_a = ((const struct sockaddr_in6 *)a)->sin6_addr.s6_addr;

124 const uint8_t *s6_addr_b = ((const struct sockaddr_in6 *)b)->sin6_addr.s6_addr;

125 return memcmp(s6_addr_a, s6_addr_b, 16);

126 }

127 #endif

128 return 1;

129 }

130

131 static int get_port(const struct sockaddr_storage *ss)

132 {

133 if (ss->ss_family == AF_INET)

134 return ntohs(((const struct sockaddr_in *)ss)->sin_port);

135 #if HAVE_STRUCT_SOCKADDR_IN6

136 if (ss->ss_family == AF_INET6)

137 return ntohs(((const struct sockaddr_in6 *)ss)->sin6_port);

138 #endif

139 return 0;

140 }

141

142 static void set_port(struct sockaddr_storage *ss, int port)

143 {

144 if (ss->ss_family == AF_INET)

145 ((struct sockaddr_in *)ss)->sin_port = htons(port);

146 #if HAVE_STRUCT_SOCKADDR_IN6

147 else if (ss->ss_family == AF_INET6)

148 ((struct sockaddr_in6 *)ss)->sin6_port = htons(port);

149 #endif

150 }

151

152 static int rtp_check_source_lists(RTPContext *s, struct sockaddr_storage *source_addr_ptr)

153 {

154 int i;

155 if (s->nb_ssm_exclude_addrs) {

156 for (i = 0; i < s->nb_ssm_exclude_addrs; i++) {

157 if (!compare_addr(source_addr_ptr, s->ssm_exclude_addrs[i]))

158 return 1;

159 }

160 }

161 if (s->nb_ssm_include_addrs) {

162 for (i = 0; i < s->nb_ssm_include_addrs; i++) {

163 if (!compare_addr(source_addr_ptr, s->ssm_include_addrs[i]))

164 return 0;

165 }

166 return 1;

167 }

168 return 0;

169 }

170

171 /**

172 * add option to url of the form:

173 * "http://host:port/path?option1=val1&option2=val2...

174 */

175

176 static av_printf_format(3, 4) void url_add_option(char *buf, int buf_size, const char *fmt, ...)

177 {

178 char buf1[1024];

179 va_list ap;

180

181 va_start(ap, fmt);

182 if (strchr(buf, '?'))

183 av_strlcat(buf, "&", buf_size);

184 else

185 av_strlcat(buf, "?", buf_size);

186 vsnprintf(buf1, sizeof(buf1), fmt, ap);

187 av_strlcat(buf, buf1, buf_size);

188 va_end(ap);

189 }

190

191 static void build_udp_url(char *buf, int buf_size,

192 const char *hostname, int port,

193 int local_port, int ttl,

194 int max_packet_size, int connect,

195 int dscp,

196 const char *include_sources,

197 const char *exclude_sources)

198 {

199 ff_url_join(buf, buf_size, "udp", NULL, hostname, port, NULL);

200 if (local_port >= 0)

201 url_add_option(buf, buf_size, "localport=%d", local_port);

202 if (ttl >= 0)

203 url_add_option(buf, buf_size, "ttl=%d", ttl);

204 if (max_packet_size >=0)

205 url_add_option(buf, buf_size, "pkt_size=%d", max_packet_size);

206 if (connect)

207 url_add_option(buf, buf_size, "connect=1");

208 if (dscp >= 0)

209 url_add_option(buf, buf_size, "dscp=%d", dscp);

210 url_add_option(buf, buf_size, "fifo_size=0");

211 if (include_sources && include_sources[0])

212 url_add_option(buf, buf_size, "sources=%s", include_sources);

213 if (exclude_sources && exclude_sources[0])

214 url_add_option(buf, buf_size, "block=%s", exclude_sources);

215 }

216

217 static void rtp_parse_addr_list(URLContext *h, char *buf,

218 struct sockaddr_storage ***address_list_ptr,

219 int *address_list_size_ptr)

220 {

221 struct addrinfo *ai = NULL;

222 struct sockaddr_storage *source_addr;

223 char tmp = '0円', *p = buf, *next;

224

225 /* Resolve all of the IPs */

226

227 while (p && p[0]) {

228 next = strchr(p, ',');

229

230 if (next) {

231 tmp = *next;

232 *next = '0円';

233 }

234

235 ai = rtp_resolve_host(p, 0, SOCK_DGRAM, AF_UNSPEC, 0);

236 if (ai) {

237 source_addr = av_mallocz(sizeof(struct sockaddr_storage));

238 if (!source_addr) {

239 freeaddrinfo(ai);

240 break;

241 }

242

243 memcpy(source_addr, ai->ai_addr, ai->ai_addrlen);

244 freeaddrinfo(ai);

245 dynarray_add(address_list_ptr, address_list_size_ptr, source_addr);

246 } else {

247 av_log(h, AV_LOG_WARNING, "Unable to resolve %s\n", p);

248 }

249

250 if (next) {

251 *next = tmp;

252 p = next + 1;

253 } else {

254 p = NULL;

255 }

256 }

257 }

258

259 /**

260 * url syntax: rtp://host:port[?option=val...]

261 * option: 'ttl=n' : set the ttl value (for multicast only)

262 * 'rtcpport=n' : set the remote rtcp port to n

263 * 'localrtpport=n' : set the local rtp port to n

264 * 'localrtcpport=n' : set the local rtcp port to n

265 * 'pkt_size=n' : set max packet size

266 * 'connect=0/1' : do a connect() on the UDP socket

267 * 'sources=ip[,ip]' : list allowed source IP addresses

268 * 'block=ip[,ip]' : list disallowed source IP addresses

269 * 'write_to_source=0/1' : send packets to the source address of the latest received packet

270 * 'dscp=n' : set DSCP value to n (QoS)

271 * deprecated option:

272 * 'localport=n' : set the local port to n

273 *

274 * if rtcpport isn't set the rtcp port will be the rtp port + 1

275 * if local rtp port isn't set any available port will be used for the local

276 * rtp and rtcp ports

277 * if the local rtcp port is not set it will be the local rtp port + 1

278 */

279

280 static int rtp_open(URLContext *h, const char *uri, int flags)

281 {

282 RTPContext *s = h->priv_data;

283 int rtp_port, rtcp_port,

284 ttl, connect,

285 local_rtp_port, local_rtcp_port, max_packet_size, dscp;

286 char hostname[256], include_sources[1024] = "", exclude_sources[1024] = "";

287 char buf[1024];

288 char path[1024];

289 const char *p;

290 int i, max_retry_count = 3;

291

292 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &rtp_port,

293 path, sizeof(path), uri);

294 /* extract parameters */

295 ttl = -1;

296 rtcp_port = rtp_port+1;

297 local_rtp_port = -1;

298 local_rtcp_port = -1;

299 max_packet_size = -1;

300 connect = 0;

301 dscp = -1;

302

303 p = strchr(uri, '?');

304 if (p) {

305 if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {

306 ttl = strtol(buf, NULL, 10);

307 }

308 if (av_find_info_tag(buf, sizeof(buf), "rtcpport", p)) {

309 rtcp_port = strtol(buf, NULL, 10);

310 }

311 if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {

312 local_rtp_port = strtol(buf, NULL, 10);

313 }

314 if (av_find_info_tag(buf, sizeof(buf), "localrtpport", p)) {

315 local_rtp_port = strtol(buf, NULL, 10);

316 }

317 if (av_find_info_tag(buf, sizeof(buf), "localrtcpport", p)) {

318 local_rtcp_port = strtol(buf, NULL, 10);

319 }

320 if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {

321 max_packet_size = strtol(buf, NULL, 10);

322 }

323 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {

324 connect = strtol(buf, NULL, 10);

325 }

326 if (av_find_info_tag(buf, sizeof(buf), "write_to_source", p)) {

327 s->write_to_source = strtol(buf, NULL, 10);

328 }

329 if (av_find_info_tag(buf, sizeof(buf), "dscp", p)) {

330 dscp = strtol(buf, NULL, 10);

331 }

332 if (av_find_info_tag(buf, sizeof(buf), "sources", p)) {

333 av_strlcpy(include_sources, buf, sizeof(include_sources));

334 rtp_parse_addr_list(h, buf, &s->ssm_include_addrs, &s->nb_ssm_include_addrs);

335 }

336 if (av_find_info_tag(buf, sizeof(buf), "block", p)) {

337 av_strlcpy(exclude_sources, buf, sizeof(exclude_sources));

338 rtp_parse_addr_list(h, buf, &s->ssm_exclude_addrs, &s->nb_ssm_exclude_addrs);

339 }

340 }

341

342 for (i = 0;i < max_retry_count;i++) {

343 build_udp_url(buf, sizeof(buf),

344 hostname, rtp_port, local_rtp_port, ttl, max_packet_size,

345 connect, dscp, include_sources, exclude_sources);

346 if (ffurl_open(&s->rtp_hd, buf, flags, &h->interrupt_callback, NULL) < 0)

347 goto fail;

348 local_rtp_port = ff_udp_get_local_port(s->rtp_hd);

349 if(local_rtp_port == 65535) {

350 local_rtp_port = -1;

351 continue;

352 }

353 if (local_rtcp_port<0) {

354 local_rtcp_port = local_rtp_port + 1;

355 build_udp_url(buf, sizeof(buf),

356 hostname, rtcp_port, local_rtcp_port, ttl, max_packet_size,

357 connect, dscp, include_sources, exclude_sources);

358 if (ffurl_open(&s->rtcp_hd, buf, flags, &h->interrupt_callback, NULL) < 0) {

359 local_rtp_port = local_rtcp_port = -1;

360 continue;

361 }

362 break;

363 }

364 build_udp_url(buf, sizeof(buf),

365 hostname, rtcp_port, local_rtcp_port, ttl, max_packet_size,

366 connect, dscp, include_sources, exclude_sources);

367 if (ffurl_open(&s->rtcp_hd, buf, flags, &h->interrupt_callback, NULL) < 0)

368 goto fail;

369 break;

370 }

371

372 /* just to ease handle access. XXX: need to suppress direct handle

373 access */

374 s->rtp_fd = ffurl_get_file_handle(s->rtp_hd);

375 s->rtcp_fd = ffurl_get_file_handle(s->rtcp_hd);

376

377 h->max_packet_size = s->rtp_hd->max_packet_size;

378 h->is_streamed = 1;

379 return 0;

380

381 fail:

382 if (s->rtp_hd)

383 ffurl_close(s->rtp_hd);

384 if (s->rtcp_hd)

385 ffurl_close(s->rtcp_hd);

386 return AVERROR(EIO);

387 }

388

389 static int rtp_read(URLContext *h, uint8_t *buf, int size)

390 {

391 RTPContext *s = h->priv_data;

392 int len, n, i;

393 struct pollfd p[2] = {{s->rtp_fd, POLLIN, 0}, {s->rtcp_fd, POLLIN, 0}};

394 int poll_delay = h->flags & AVIO_FLAG_NONBLOCK ? 0 : 100;

395 struct sockaddr_storage *addrs[2] = { &s->last_rtp_source, &s->last_rtcp_source };

396 socklen_t *addr_lens[2] = { &s->last_rtp_source_len, &s->last_rtcp_source_len };

397

398 for(;;) {

399 if (ff_check_interrupt(&h->interrupt_callback))

400 return AVERROR_EXIT;

401 n = poll(p, 2, poll_delay);

402 if (n > 0) {

403 /* first try RTCP, then RTP */

404 for (i = 1; i >= 0; i--) {

405 if (!(p[i].revents & POLLIN))

406 continue;

407 *addr_lens[i] = sizeof(*addrs[i]);

408 len = recvfrom(p[i].fd, buf, size, 0,

409 (struct sockaddr *)addrs[i], addr_lens[i]);

410 if (len < 0) {

411 if (ff_neterrno() == AVERROR(EAGAIN) ||

412 ff_neterrno() == AVERROR(EINTR))

413 continue;

414 return AVERROR(EIO);

415 }

416 if (rtp_check_source_lists(s, addrs[i]))

417 continue;

418 return len;

419 }

420 } else if (n < 0) {

421 if (ff_neterrno() == AVERROR(EINTR))

422 continue;

423 return AVERROR(EIO);

424 }

425 if (h->flags & AVIO_FLAG_NONBLOCK)

426 return AVERROR(EAGAIN);

427 }

428 return len;

429 }

430

431 static int rtp_write(URLContext *h, const uint8_t *buf, int size)

432 {

433 RTPContext *s = h->priv_data;

434 int ret;

435 URLContext *hd;

436

437 if (size < 2)

438 return AVERROR(EINVAL);

439

440 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))

441 av_log(h, AV_LOG_WARNING, "Data doesn't look like RTP packets, "

442 "make sure the RTP muxer is used\n");

443

444 if (s->write_to_source) {

445 int fd;

446 struct sockaddr_storage *source, temp_source;

447 socklen_t *source_len, temp_len;

448 if (!s->last_rtp_source.ss_family && !s->last_rtcp_source.ss_family) {

449 av_log(h, AV_LOG_ERROR,

450 "Unable to send packet to source, no packets received yet\n");

451 // Intentionally not returning an error here

452 return size;

453 }

454

455 if (RTP_PT_IS_RTCP(buf[1])) {

456 fd = s->rtcp_fd;

457 source = &s->last_rtcp_source;

458 source_len = &s->last_rtcp_source_len;

459 } else {

460 fd = s->rtp_fd;

461 source = &s->last_rtp_source;

462 source_len = &s->last_rtp_source_len;

463 }

464 if (!source->ss_family) {

465 source = &temp_source;

466 source_len = &temp_len;

467 if (RTP_PT_IS_RTCP(buf[1])) {

468 temp_source = s->last_rtp_source;

469 temp_len = s->last_rtp_source_len;

470 set_port(source, get_port(source) + 1);

471 av_log(h, AV_LOG_INFO,

472 "Not received any RTCP packets yet, inferring peer port "

473 "from the RTP port\n");

474 } else {

475 temp_source = s->last_rtcp_source;

476 temp_len = s->last_rtcp_source_len;

477 set_port(source, get_port(source) - 1);

478 av_log(h, AV_LOG_INFO,

479 "Not received any RTP packets yet, inferring peer port "

480 "from the RTCP port\n");

481 }

482 }

483

484 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {

485 ret = ff_network_wait_fd(fd, 1);

486 if (ret < 0)

487 return ret;

488 }

489 ret = sendto(fd, buf, size, 0, (struct sockaddr *) source,

490 *source_len);

491

492 return ret < 0 ? ff_neterrno() : ret;

493 }

494

495 if (RTP_PT_IS_RTCP(buf[1])) {

496 /* RTCP payload type */

497 hd = s->rtcp_hd;

498 } else {

499 /* RTP payload type */

500 hd = s->rtp_hd;

501 }

502

503 ret = ffurl_write(hd, buf, size);

504 return ret;

505 }

506

507 static int rtp_close(URLContext *h)

508 {

509 RTPContext *s = h->priv_data;

510 int i;

511

512 for (i = 0; i < s->nb_ssm_include_addrs; i++)

513 av_freep(&s->ssm_include_addrs[i]);

514 av_freep(&s->ssm_include_addrs);

515 for (i = 0; i < s->nb_ssm_exclude_addrs; i++)

516 av_freep(&s->ssm_exclude_addrs[i]);

517 av_freep(&s->ssm_exclude_addrs);

518

519 ffurl_close(s->rtp_hd);

520 ffurl_close(s->rtcp_hd);

521 return 0;

522 }

523

524 /**

525 * Return the local rtp port used by the RTP connection

526 * @param h media file context

527 * @return the local port number

528 */

529

530 int ff_rtp_get_local_rtp_port(URLContext *h)

531 {

532 RTPContext *s = h->priv_data;

533 return ff_udp_get_local_port(s->rtp_hd);

534 }

535

536 /**

537 * Return the local rtcp port used by the RTP connection

538 * @param h media file context

539 * @return the local port number

540 */

541

542 int ff_rtp_get_local_rtcp_port(URLContext *h)

543 {

544 RTPContext *s = h->priv_data;

545 return ff_udp_get_local_port(s->rtcp_hd);

546 }

547

548 static int rtp_get_file_handle(URLContext *h)

549 {

550 RTPContext *s = h->priv_data;

551 return s->rtp_fd;

552 }

553

554 static int rtp_get_multi_file_handle(URLContext *h, int **handles,

555 int *numhandles)

556 {

557 RTPContext *s = h->priv_data;

558 int *hs = *handles = av_malloc(sizeof(**handles) * 2);

559 if (!hs)

560 return AVERROR(ENOMEM);

561 hs[0] = s->rtp_fd;

562 hs[1] = s->rtcp_fd;

563 *numhandles = 2;

564 return 0;

565 }

566

567 URLProtocol ff_rtp_protocol = {

568 .name = "rtp",

569 .url_open = rtp_open,

570 .url_read = rtp_read,

571 .url_write = rtp_write,

572 .url_close = rtp_close,

573 .url_get_file_handle = rtp_get_file_handle,

574 .url_get_multi_file_handle = rtp_get_multi_file_handle,

575 .priv_data_size = sizeof(RTPContext),

576 .flags = URL_PROTOCOL_FLAG_NETWORK,

577 };

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