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 const char *include_sources,

196 const char *exclude_sources)

197 {

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

199 if (local_port >= 0)

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

201 if (ttl >= 0)

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

203 if (max_packet_size >=0)

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

205 if (connect)

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

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

208 if (include_sources && include_sources[0])

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

210 if (exclude_sources && exclude_sources[0])

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

212 }

213

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

215 struct sockaddr_storage ***address_list_ptr,

216 int *address_list_size_ptr)

217 {

218 struct addrinfo *ai = NULL;

219 struct sockaddr_storage *source_addr;

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

221

222 /* Resolve all of the IPs */

223

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

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

226

227 if (next) {

228 tmp = *next;

229 *next = '0円';

230 }

231

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

233 if (ai) {

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

235 if (!source_addr)

236 break;

237

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

239 freeaddrinfo(ai);

240 dynarray_add(address_list_ptr, address_list_size_ptr, source_addr);

241 } else {

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

243 }

244

245 if (next) {

246 *next = tmp;

247 p = next + 1;

248 } else {

249 p = NULL;

250 }

251 }

252 }

253

254 /**

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

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

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

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

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

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

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

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

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

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

265 * deprecated option:

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

267 *

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

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

270 * rtp and rtcp ports

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

272 */

273

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

275 {

276 RTPContext *s = h->priv_data;

277 int rtp_port, rtcp_port,

278 ttl, connect,

279 local_rtp_port, local_rtcp_port, max_packet_size;

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

281 char buf[1024];

282 char path[1024];

283 const char *p;

284 int i, max_retry_count = 3;

285

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

287 path, sizeof(path), uri);

288 /* extract parameters */

289 ttl = -1;

290 rtcp_port = rtp_port+1;

291 local_rtp_port = -1;

292 local_rtcp_port = -1;

293 max_packet_size = -1;

294 connect = 0;

295

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

297 if (p) {

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

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

300 }

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

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

303 }

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

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

306 }

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

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

309 }

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

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

312 }

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

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

315 }

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

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

318 }

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

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

321 }

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

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

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

325 }

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

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

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

329 }

330 }

331

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

333 build_udp_url(buf, sizeof(buf),

334 hostname, rtp_port, local_rtp_port, ttl, max_packet_size,

335 connect, include_sources, exclude_sources);

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

337 goto fail;

338 local_rtp_port = ff_udp_get_local_port(s->rtp_hd);

339 if(local_rtp_port == 65535) {

340 local_rtp_port = -1;

341 continue;

342 }

343 if (local_rtcp_port<0) {

344 local_rtcp_port = local_rtp_port + 1;

345 build_udp_url(buf, sizeof(buf),

346 hostname, rtcp_port, local_rtcp_port, ttl, max_packet_size,

347 connect, include_sources, exclude_sources);

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

349 local_rtp_port = local_rtcp_port = -1;

350 continue;

351 }

352 break;

353 }

354 build_udp_url(buf, sizeof(buf),

355 hostname, rtcp_port, local_rtcp_port, ttl, max_packet_size,

356 connect, include_sources, exclude_sources);

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

358 goto fail;

359 break;

360 }

361

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

363 access */

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

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

366

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

368 h->is_streamed = 1;

369 return 0;

370

371 fail:

372 if (s->rtp_hd)

373 ffurl_close(s->rtp_hd);

374 if (s->rtcp_hd)

375 ffurl_close(s->rtcp_hd);

376 return AVERROR(EIO);

377 }

378

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

380 {

381 RTPContext *s = h->priv_data;

382 int len, n, i;

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

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

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

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

387

388 for(;;) {

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

390 return AVERROR_EXIT;

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

392 if (n > 0) {

393 /* first try RTCP, then RTP */

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

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

396 continue;

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

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

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

400 if (len < 0) {

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

402 ff_neterrno() == AVERROR(EINTR))

403 continue;

404 return AVERROR(EIO);

405 }

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

407 continue;

408 return len;

409 }

410 } else if (n < 0) {

411 if (ff_neterrno() == AVERROR(EINTR))

412 continue;

413 return AVERROR(EIO);

414 }

415 if (h->flags & AVIO_FLAG_NONBLOCK)

416 return AVERROR(EAGAIN);

417 }

418 return len;

419 }

420

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

422 {

423 RTPContext *s = h->priv_data;

424 int ret;

425 URLContext *hd;

426

427 if (size < 2)

428 return AVERROR(EINVAL);

429

430 if (s->write_to_source) {

431 int fd;

432 struct sockaddr_storage *source, temp_source;

433 socklen_t *source_len, temp_len;

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

435 av_log(h, AV_LOG_ERROR,

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

437 // Intentionally not returning an error here

438 return size;

439 }

440

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

442 fd = s->rtcp_fd;

443 source = &s->last_rtcp_source;

444 source_len = &s->last_rtcp_source_len;

445 } else {

446 fd = s->rtp_fd;

447 source = &s->last_rtp_source;

448 source_len = &s->last_rtp_source_len;

449 }

450 if (!source->ss_family) {

451 source = &temp_source;

452 source_len = &temp_len;

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

454 temp_source = s->last_rtp_source;

455 temp_len = s->last_rtp_source_len;

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

457 av_log(h, AV_LOG_INFO,

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

459 "from the RTP port\n");

460 } else {

461 temp_source = s->last_rtcp_source;

462 temp_len = s->last_rtcp_source_len;

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

464 av_log(h, AV_LOG_INFO,

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

466 "from the RTCP port\n");

467 }

468 }

469

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

471 ret = ff_network_wait_fd(fd, 1);

472 if (ret < 0)

473 return ret;

474 }

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

476 *source_len);

477

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

479 }

480

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

482 /* RTCP payload type */

483 hd = s->rtcp_hd;

484 } else {

485 /* RTP payload type */

486 hd = s->rtp_hd;

487 }

488

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

490 return ret;

491 }

492

493 static int rtp_close(URLContext *h)

494 {

495 RTPContext *s = h->priv_data;

496 int i;

497

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

499 av_free(s->ssm_include_addrs[i]);

500 av_freep(&s->ssm_include_addrs);

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

502 av_free(s->ssm_exclude_addrs[i]);

503 av_freep(&s->ssm_exclude_addrs);

504

505 ffurl_close(s->rtp_hd);

506 ffurl_close(s->rtcp_hd);

507 return 0;

508 }

509

510 /**

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

512 * @param h media file context

513 * @return the local port number

514 */

515

516 int ff_rtp_get_local_rtp_port(URLContext *h)

517 {

518 RTPContext *s = h->priv_data;

519 return ff_udp_get_local_port(s->rtp_hd);

520 }

521

522 /**

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

524 * @param h media file context

525 * @return the local port number

526 */

527

528 int ff_rtp_get_local_rtcp_port(URLContext *h)

529 {

530 RTPContext *s = h->priv_data;

531 return ff_udp_get_local_port(s->rtcp_hd);

532 }

533

534 static int rtp_get_file_handle(URLContext *h)

535 {

536 RTPContext *s = h->priv_data;

537 return s->rtp_fd;

538 }

539

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

541 int *numhandles)

542 {

543 RTPContext *s = h->priv_data;

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

545 if (!hs)

546 return AVERROR(ENOMEM);

547 hs[0] = s->rtp_fd;

548 hs[1] = s->rtcp_fd;

549 *numhandles = 2;

550 return 0;

551 }

552

553 URLProtocol ff_rtp_protocol = {

554 .name = "rtp",

555 .url_open = rtp_open,

556 .url_read = rtp_read,

557 .url_write = rtp_write,

558 .url_close = rtp_close,

559 .url_get_file_handle = rtp_get_file_handle,

560 .url_get_multi_file_handle = rtp_get_multi_file_handle,

561 .priv_data_size = sizeof(RTPContext),

562 .flags = URL_PROTOCOL_FLAG_NETWORK,

563 };

Generated on Sun Sep 14 2014 18:56:15 for FFmpeg by doxygen 1.8.2